DEV Community: Zain Khan

I Built a Workflow That Watches Congress Members' Stock Trades in Real Time

Zain Khan — Tue, 28 Jul 2026 11:19:20 +0000

Congress members are required to disclose their stock trades, but "disclosed" doesn't mean "easy to find." One source is a raw SEC Atom feed. The other is a government site that occasionally hands you a PDF where the actual trade details are buried in a fixed-width table with no clean structure. Nobody's checking either of these by hand every 45 minutes, so nobody catches a new filing until it's already old news.

I built a workflow that does check, every 45 minutes, pulling from both sources directly, enriching the raw filings with actual transaction data, and firing off an email the moment something genuinely new shows up.

The stack

Built entirely on n8n, pulling straight from SEC EDGAR and House.gov, with results logged to Google Sheets and alerts sent through Gmail.

The interesting part of this one isn't the orchestration, it's the data access. Both SEC EDGAR and House.gov actively push back against generic scraping. SEC EDGAR returns a 403 to any request without a declared, compliant User-Agent, that's their actual fair-access policy, not a bug. House.gov's disclosure ZIPs behave similarly with generic scraping tools. So instead of routing these requests through a scraping service that can't set custom headers, this workflow calls n8n's built-in HTTP helper directly inside Code nodes, with a real User-Agent string identifying the tool and a contact email, exactly what SEC's policy asks for. No trickery, just compliance.

How it works
A 45-minute schedule kicks off two parallel fetches: the SEC EDGAR Form 4 Atom feed, and the House.gov disclosure landing page.
On the House side, a code step scrapes the current year's ZIP archive URL out of the landing page HTML, downloads it as raw binary (again via the built-in HTTP helper, since ScrapeUnblocker 403s on binary files), and decompresses it.
The decompressed archive gets parsed for Periodic Transaction Reports specifically, filtering by FilingType: P, whether the underlying file is XML or tab-delimited text.
On the EDGAR side, the Atom feed gets parsed for Form 4 filings, keeping only the reporting person's entry and dropping the duplicate issuer-side row that the feed also includes.
Both sources merge into one shared schema, then get checked against a running list of filing IDs already logged in Google Sheets. A recency gate also drops anything older than 20 days, so the very first run doesn't treat the entire historical archive as "new."
Genuinely new filings get enriched. For EDGAR, that means fetching the filing's own directory index, locating the ownership XML, and parsing out real transaction data, shares, price, dollar value, deduping identical legs that option exercises tend to double-list. For House filings not covered by the bulk XML, the workflow downloads the actual PTR PDF and extracts trade rows straight out of the PDF text with pattern matching, since the PDF-extraction step wipes out all the upstream fields it would otherwise rely on.
Everything gets logged to Google Sheets, and if anything new made it through, an email alert goes out with the details.
The part worth calling out

The PDF parsing step is the most fragile part of this by design, and the code says so honestly in its own comments: it's best-effort, and a scanned (non-text) PDF will yield nothing. That's a reasonable tradeoff. Government PDFs aren't guaranteed to be clean, and building a workflow that fails loudly on bad input is far better than one that silently fabricates data. The dedup logic against Google Sheets, plus the recency gate, is what keeps this from becoming an alert-spam machine on day one.

Setting it up yourself
Point the schedule trigger at whatever check interval works for you (45 minutes is a reasonable default for filings that don't post more than a few times a day).
Edit the USER_AGENT string in both the EDGAR fetch and enrichment code nodes to include your real contact email, SEC requires this, and it's a one-line edit.
Connect Google Sheets for the seen-filings log and the trade log itself.
Connect Gmail (or swap in Slack, Telegram, whatever fits your workflow) for the alert step.

Final thought
Public disclosure only means something if someone's actually watching it. Most of these filings sit in feeds and PDFs that are technically public but practically invisible unless you're checking constantly. Pulling directly from the source, respecting each site's actual access policy instead of routing around it, is what makes this the kind of workflow you can leave running unattended and trust.

I Built a Lead Qualification Pipeline That Scores, Summarizes, and Emails Leads Automatically

Zain Khan — Wed, 22 Jul 2026 12:28:11 +0000

A new lead lands in your spreadsheet. Someone still has to read it, decide if it's worth chasing, write a summary for context, and draft an email that doesn't sound like a template. Multiply that by every lead your forms bring in, and "follow up quickly" quietly becomes the bottleneck.

So I automated the qualification and the outreach both. The moment a new row hits the sheet, the lead gets scored, and only the ones worth pursuing get summarized, drafted into a personal email, sent, and logged back with the full paper trail. Grab the workflow from here

The stack

Built on n8n, using CometAPI for every AI step, scoring, summarizing, and drafting the outreach email.

Using one API for all three steps keeps the pipeline simple: three prompts, one credential, no juggling separate provider keys or response formats across nodes.

How it works
A Google Sheets trigger fires the moment a new lead row is added.
CometAPI scores the lead from 1–10 based on name, company, and message, returning the number plus a short reason.
A Code node extracts the numeric score with a regex match, falling back to 0 if nothing parses, so a slightly off-format response never crashes the run.
An IF node checks the score against a threshold (7 and above, in this case).
If it qualifies: CometAPI summarizes the lead's needs and how they found you, then drafts a short, friendly outreach email under 120 words with a clear call to action, which gets sent straight through Gmail.
Either way, the lead is logged to a second Google Sheet, name, email, company, message, score, summary, and the email draft, matched and updated by email address, so re-processing the same lead never creates a duplicate row.

New row → scored → qualified or skipped → summarized, drafted, and emailed if it clears the bar → logged either way.

Why it's worth copying

It filters before it spends effort. Only leads that clear the threshold get the summary and email steps, so CometAPI calls (and your team's attention) go where they're actually justified.
It fails safely. The score extraction never throws on a malformed response, it just defaults low instead of breaking the workflow.
It's a real paper trail, not just an inbox. Every score, summary, and draft is logged back to Sheets, so nothing about a lead's journey is a mystery later.
Setting it up yourself
Point the Google Sheets trigger at your leads sheet.
Add your CometAPI credentials to the scoring, summarizing, and drafting nodes.
Set your qualification threshold on the IF node.
Connect Gmail for outreach, and point the final Sheets node at wherever you want results logged.

Want a different threshold, a longer email, or an extra qualification factor like budget or timeline? It's a prompt or a condition edit, nothing structural changes.

Final thought

Lead qualification doesn't need a human in the loop for every single row, it needs one for the leads that matter. Pairing n8n's branching logic with CometAPI's scoring and drafting turns "someone should follow up with this" into something that already happened by the time you check your inbox.

I Turned My Blog Into a Podcast Without Recording a Single Word

Zain Khan — Mon, 20 Jul 2026 13:00:52 +0000

Not everyone wants to read your blog. Some people want to listen to it on a walk, during a commute, or while doing dishes. Turning written content into audio is one of the highest-leverage things you can do for reach, but recording, editing, and publishing narration for every single post is its own part-time job.
So I automated the entire pipeline. Now, the moment I publish a new blog post, it's rewritten for the ear, narrated, and embedded back into the article as a playable audio player, with zero manual work.

Here's exactly how it works
and how to set up the same thing for your own blog. If you'd rather skip ahead, Grab the workflow from here

This runs on n8n, using Google Gemini to rewrite the article for spoken word and Smallest.ai to turn that script into natural-sounding audio.
The rewrite step matters more than people expect. A blog post written for the eye is full of things that sound terrible read aloud — bullet points, headings, stray URLs, abbreviations. So instead of just piping raw text into a TTS engine, this workflow rewrites it into something that actually sounds like a person talking, then hands it to Smallest.ai, which is what makes the final audio sound like a real narration instead of a robotic reading of a web page.
How the workflow actually works

Watch the RSS feed the workflow polls your blog's RSS feed on a schedule. The moment a new post shows up, it kicks off.
Strip it down to clean text, a code step strips out all the HTML, formatting, and leftover markup, leaving just the raw article text to work with.
Rewrite it for the ear, a Google Gemini agent rewrites the post specifically for narration: bullet points become flowing sentences, numbers and abbreviations are spelled out, stray captions and credits are removed, and it adds a natural spoken intro and outro. The result reads like a script, not an article.
Synthesize the narration, that script is sent to Smallest.ai, which generates a clean MP3 narration of the piece.
Host and embed the audio, the audio file is uploaded to Google Drive, made publicly accessible, and an audio player is automatically embedded at the top of the original WordPress post, so readers can either read or listen.

New post published → rewritten, narrated, hosted, and embedded, all before you've finished your coffee.
Why this setup is worth copying

It multiplies your content without multiplying your effort. Every post you already write becomes an audio piece for free.
It sounds like narration, not a text reader. The rewrite step is what separates a listenable article from a robotic wall of text being read aloud.
It's a real accessibility win. Not everyone can or wants to read, this gives every post an audio alternative by default.

Setting it up yourself

Point the RSS Feed Trigger at your blog's feed URL.
Authenticate Google Gemini inside the LangChain chat model node.
Add your Smallest.ai API credentials to the speech synthesis node.
Connect your Google Drive and WordPress accounts for hosting and embedding.

Want a different narration tone, a custom intro/outro, or a shorter target length? It's a single prompt edit inside the AI Agent - Rewrite for Audio node.
Final thought
Repurposing content into audio is exactly the kind of task that's valuable but tedious enough that most people never actually do it consistently. Pairing n8n's orchestration with Smallest.ai's speech synthesis turned it into something that just happens in the background, every time you hit publish.

If you build on top of this, I'd love to see what you add to it.

The Messaging Delta Tracker: Your Competitor Changed Their Ad Strategy Last Week. Did You Notice?

Zain Khan — Fri, 03 Jul 2026 18:21:01 +0000

Competitors don't announce strategy shifts. They just start running different ads.

A new headline here. A dropped value prop there. Suddenly they're talking to "enterprise teams" instead of "small businesses," or leading with a price point they never mentioned before. By the time it's obvious enough to notice by eye, it's been true for weeks.

This build closes that gap. It's an n8n workflow that quietly watches a list of competitors every Monday, pulls their live ads, and asks an AI agent one blunt question: what changed, and should anyone care? Grab the full workflow JSON here and follow along.

It runs entirely on n8n Cloud, no local install, no docker. Sign in, import the workflow, plug in your credentials, and it's live.

The Solution
At the center of this workflow is Adyntel, an ad intelligence node that fetches live ad data from Meta, Google, and LinkedIn using nothing but a company's domain. That alone is useful. The interesting part is what happens next.

Every week, the workflow saves a snapshot of a competitor's ad copy. The following week, it pulls last week's snapshot back out and hands both weeks, old and new, to an AI agent trained to think like a competitive intelligence analyst. It doesn't just list differences; it interprets them. Did the angle shift from features to social proof? Did a new audience segment show up? Is this a minor tweak, or does it smell like something bigger — a repositioning, a new product, a fundraising push?

The agent scores its own answer with an urgency rating. Low and Medium urgency shifts get logged quietly for the record. High urgency shifts get pushed straight to Slack, because that's the kind of thing you want to know about before your next planning meeting, not after.

What We'll Build

Trigger: A weekly schedule fires every Monday at 9 AM — no one has to remember to run this.
Load: Pull competitors marked "Pending" from a Google Sheet.
Collect: Fetch this week's live ads for each competitor across Meta, Google, and LinkedIn.
Normalize: Extract clean ad titles and body copy, deduplicated, from three very differently shaped API responses.
Recall: Pull last week's snapshot of the same competitor's ads back out of storage.
Compare: Work out exactly which ad titles are new this week and which ones quietly disappeared.
Interpret: Hand both weeks to an AI agent that names the strategic shift, not just the text difference.
Store: Save this week's snapshot and the AI's delta analysis to Google Sheets.
Escalate: If the urgency rating comes back High, fire a Slack alert immediately.

Set Up the Weekly Trigger and Competitor List

Add a Schedule Trigger node set to the cron expression below, every Monday, 9 AM, no manual kickoff required.

0 9 * * 1

Right after it, a Google Sheets node reads a competitors tab, filtered to rows where status equals Pending. That filter matters: it's what lets you pause a competitor without deleting their row, just by flipping the status. Each row only needs a domain and a competitor_name, everything downstream keys off the domain.

A Split In Batches node then loops through competitors one at a time, so a slow API response from one competitor never blocks the rest of the list.

All three connect to the same Adyntel credential, so you only need to authenticate once. A Merge node (combine by position) brings all three results back together into a single stream before the real work starts.

From there, a Code node called Extract This Week's Copy does the unglamorous part: Meta, Google, and LinkedIn all shape their ad payloads differently, and this node normalizes all three into one consistent structure, platform, ad title, ad body, while deduplicating anything that shows up twice. If a competitor genuinely has no active ads that week, it doesn't error out; it returns a sentinel row so the rest of the workflow can handle "gone dark" as a real outcome instead of a crash.

Set Up the Comparison and the AI Delta Analysis
This is where last week meets this week.
A Google Sheets node reads the previous snapshot for the same domain from an ad_copy_snapshots tab, filtered by domain and the prior week's date. A Code node called Build Comparison Context lines the two weeks up side by side and works out exactly which ad titles are new and which ones dropped off, plain set comparison, no AI needed yet.
Then it gets handed to the model.

Get an API key from OpenAI and add it under Credentials > OpenAI in n8n.
Add an AI Agent node (with an OpenAI Chat Model attached) named AI Agent — Detect Messaging Delta.
Its system message positions it as a competitive intelligence analyst, told specifically to watch for angle changes (features vs. benefits vs. social proof vs. urgency), audience shifts, new product or feature names, value proposition changes, and tone shifts.
The prompt passes in both weeks of ad copy plus the new/dropped title lists, and asks for a strict JSON response:

{
  "angle_shift": "one sentence describing any pivot in core message angle",
  "new_audiences": "comma-separated audience segments targeted by new ads",
  "new_value_props": "comma-separated new value propositions or features",
  "urgency_signal": "High or Medium or Low",
  "urgency_reason": "one sentence explaining the urgency rating",
  "delta_summary": "2-3 sentence plain-English summary of what changed",
  "new_ad_titles": "semicolon-separated list of new ad titles",
  "dropped_ad_titles": "semicolon-separated list of dropped ad titles"
}

A Parse Delta Result Code node handles the model's response, including the messy cases where it doesn't return perfectly clean JSON, falling back to regex extraction and keyword-based urgency detection if needed, so one oddly formatted response doesn't take down the run.

Set Up Storage and the Slack Escalation

Two Google Sheets nodes handle the record-keeping: Prepare Snapshot Rows / Append to Snapshots logs this week's raw ad copy for next week's comparison, and a second append step logs the AI's delta analysis, angle shift, urgency, reasoning, and summary, as its own row.

An If node (Urgency = High?) checks the AI's rating. Anything Medium or Low loops quietly back to the next competitor. Anything High routes to Format Slack Alert, which builds a message with a color-coded emoji (🔴 High, 🟡 Medium, 🟢 Low), the competitor name, what changed, the new angle, and the specific ads added or dropped — then a Slack node sends it to whichever channel your team actually watches.

Either path loops back to Loop Over Competitors, and the cycle continues until every competitor on the list has been checked for the week.

Trigger the Workflow
Host it in n8n Cloud and let the Monday schedule handle itself, or click "Test Workflow" to run it on demand the first time. It'll pull your competitor list, gather ads from three platforms, compare this week against last, and, if anything crosses the urgency threshold, land in Slack before you've had a chance to check LinkedIn yourself.

Conclusion
Most competitive intelligence tools tell you that something changed. This one tries to tell you what it means, and only interrupts your day when it actually matters. Point it at a longer competitor list, tighten the urgency criteria to match what your team cares about, or swap Slack for email, the pattern holds either way. Build the version that watches what you can't afford to miss.