DEV Community: Pirate Prentice

How to run n8n workflows on a schedule (cron, daily, weekly — with free JSON)

Pirate Prentice — Thu, 25 Jun 2026 19:31:34 +0000

Most n8n tutorials show you how to trigger a workflow from a webhook or button click. But some of the most useful automations run on their own — every morning, every Monday, the first of the month. No webhook needed. No human in the loop.

Here's how to set that up in n8n with the Schedule Trigger node.

The Schedule Trigger node

In n8n, the node you want is called Schedule Trigger (you might also see it called "Cron" in older versions). It has zero inputs and fires your workflow automatically at whatever interval you configure.

To add it:

Open a new workflow in n8n
Click + Add node
Search for Schedule Trigger
Select it as your workflow's starting node

Setting the interval

The node gives you several modes:

Every X minutes / hours
Good for monitoring tasks: check a Slack channel every 15 minutes, ping an API every hour to look for updates.

Every day at a specific time
The most common setup. Example: send a daily summary email at 8 AM every weekday.

Every week on a specific day
Good for reports: generate a weekly CSV every Monday at 9 AM.

Every month on a specific day
Good for billing checks, monthly digests, first-of-month resets.

Custom cron expression
If you need fine-grained control: 0 8 * * 1-5 runs at 8 AM Monday through Friday. n8n accepts standard 5-field cron syntax.

Real example: Daily digest email

Here's a simple pattern that runs every morning at 8 AM and sends you a summary email:

Schedule Trigger (every day at 08:00)
  → HTTP Request (fetch your data)
  → Set (format the data)
  → Send Email (Gmail or SMTP)

The workflow fires automatically. You wake up to a digest without touching anything.

Real example: Weekly Slack report

Schedule Trigger (every Monday at 09:00)
  → Google Sheets (pull last week's rows)
  → Code node (calculate totals)
  → Slack (post to #reports)

Free workflow JSON (copy-paste ready)

Here's a minimal Schedule Trigger → Send Email workflow you can import directly into n8n:

{
  "name": "Daily Schedule → Email",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [{ "field": "hours", "hoursInterval": 24 }],
          "triggerAtHour": 8
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "fromEmail": "you@example.com",
        "toEmail": "you@example.com",
        "subject": "Daily digest",
        "text": "Workflow ran at {{ $now.toISO() }}"
      },
      "name": "Send Email",
      "type": "n8n-nodes-base.emailSend",
      "typeVersion": 2,
      "position": [460, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [[{ "node": "Send Email", "type": "main", "index": 0 }]]
    }
  }
}

To import: In n8n → workflow list → Import from clipboard → paste.

Timezone gotcha

n8n runs in the timezone of your server. After setting up your Schedule Trigger, check the Next execution preview. If it shows the wrong time, fix your server timezone or use a UTC cron expression adjusted manually.

Want more pre-built workflows?

The n8n Workflow Starter Pack includes production-ready workflow JSONs — Stripe receipt automation, lead-capture-to-CRM, and form-to-Sheets — all documented and import-ready.

👉 Get the Starter Pack ($29)

Questions? Drop them in the comments — I reply same day.

How to connect n8n to ChatGPT (OpenAI) — build your first AI automation in 10 minutes

Pirate Prentice — Thu, 25 Jun 2026 16:30:18 +0000

If you've been using n8n for automations but haven't connected it to ChatGPT yet, this is the tutorial for you.

n8n has a native OpenAI node that makes it surprisingly easy to add AI to any workflow — no custom API code required. In this post I'll walk you through building a real working AI automation from scratch.

What we're building

A workflow that:

Receives a webhook (from a form, Slack, or anything)
Passes the input to ChatGPT
Returns the AI-generated response — to email, Slack, Google Sheets, wherever you need it

This is the foundation pattern for almost every AI automation in n8n. Once you have this wired up, you can swap in any trigger and any output.

Prerequisites

n8n running (cloud or self-hosted)
An OpenAI API key (platform.openai.com)
10 minutes

Step 1 — Create a new workflow and add a Webhook trigger

In n8n, click + New Workflow
Add a Webhook node as your trigger
Set the HTTP method to POST
Copy the webhook URL — you'll use it to send test data

The webhook will receive a JSON body with whatever input you want to send to ChatGPT. For this tutorial we'll use:

{
  "message": "Summarize the following in one sentence: n8n is an open-source workflow automation tool that lets you connect apps and automate tasks without writing code."
}

Step 2 — Add the OpenAI node

After the Webhook node, click + to add a new node
Search for OpenAI and select it
Choose the Message a Model operation
Create a new credential: paste your OpenAI API key

Model settings:

Model: gpt-4o-mini (fast and cheap — ideal for automations)
User Message: {{ $json.message }} — this pulls the message from the webhook body
System Prompt (optional): You are a helpful assistant. Be concise.

That's it. n8n handles the API call, authentication, and response parsing automatically.

Step 3 — Use the response

The OpenAI node outputs the response text at:

{{ $json.message.content }}

From here you can pipe it anywhere:

Send Email node → email the AI response
Slack node → post it to a channel
Google Sheets node → log it to a spreadsheet
Respond to Webhook node → return it to the caller as JSON

For testing, add a Respond to Webhook node at the end with body {{ $json.message.content }} — that way you can hit the webhook URL and get the AI response back in real time.

Step 4 — Test it

Activate the workflow
Send a POST request to your webhook URL with the JSON body above (use curl, Postman, or any HTTP tool)
You should get back a clean one-sentence summary from ChatGPT in under 2 seconds

Real-world uses for this pattern

Once you have the base pattern working, here's what people actually build with it:

Use case	Trigger	What ChatGPT does
Auto-classify support tickets	Email receive	Tags tickets by urgency/topic
AI email drafts	New CRM lead	Drafts a personalized outreach email
Form response summarizer	Tally/Typeform webhook	Summarizes long-form answers
Slack Q&A bot	Slack mention	Answers questions from a knowledge base
Invoice data extraction	Email attachment	Extracts line items into Google Sheets

All of these use the same skeleton: trigger → OpenAI node → output node.

Common issues

"I get an authentication error" — double-check your OpenAI API key in n8n credentials. Make sure you're using a key from the project you have billing set up for.

"The response is empty" — check your expression path. In newer n8n versions the response is at {{ $json.message.content }}. In older versions it may be at {{ $json.choices[0].message.content }}.

"It's slow" — switch from gpt-4o to gpt-4o-mini. For most automation tasks the quality difference is negligible and latency drops from ~3s to ~0.5s.

Want pre-built workflows that already use this pattern?

I put together an n8n Workflow Starter Pack — 5 production-ready workflow JSONs you can import and run immediately, including a lead-capture AI workflow that uses OpenAI to score and categorize inbound leads automatically.

Get the n8n Workflow Starter Pack ($29) →

Drop a comment below if you get stuck on any of the steps and I'll help you debug it.

How to automatically add new leads to your CRM with n8n (free workflow JSON)

Pirate Prentice — Thu, 25 Jun 2026 13:29:24 +0000

Every lead capture form should do three things automatically: save the lead somewhere, notify the right person, and send a welcome email. Most people build this once, badly, and then rebuild it every time they start a new project.

I rebuilt it four times before I finally wrote it down properly as an n8n workflow. This is that workflow — free JSON at the end.

What this workflow does

Receives a webhook POST from your form (Tally, Typeform, Webflow, or a plain HTML form)
Saves the lead to Airtable (or Google Sheets — I'll show both)
Posts a Slack message to your #leads channel
Sends a personalized welcome email via Gmail or SMTP

No paid n8n nodes. No external services beyond what you're probably already using.

Prerequisites

n8n running (self-hosted free, or n8n Cloud — the workflow works on both)
An Airtable account (free tier works)
Slack workspace with a #leads channel
A form that can send a POST webhook (Tally is free and does this natively)

Step 1: Set up your Airtable base

Create a base called Leads with these fields:

Field	Type
Name	Single line text
Email	Email
Source	Single line text
Created	Date
Status	Single select (New / Contacted / Qualified)

Copy your Airtable base ID from the URL: https://airtable.com/appXXXXXXXXXXXXXX/... — that appXXX... part is your base ID.

Step 2: Build the n8n workflow

Open n8n and create a new workflow. Add these nodes in order:

Node 1 — Webhook (trigger)

Authentication: None (or Header Auth if you want security)
HTTP Method: POST
Path: /new-lead
Response Mode: Immediately

This gives you a URL like https://your-n8n.com/webhook/new-lead — that's what your form will POST to.

Node 2 — Set (normalize the data)

Map incoming form fields to consistent variable names. Form providers use different field names — Tally uses fields[0].value, Typeform uses answers[0].text. The Set node creates a clean intermediate shape:

name  → {{ $json.body.name ?? $json.body["Name"] ?? "Unknown" }}
email → {{ $json.body.email ?? $json.body["Email"] }}
source → {{ $json.body.source ?? "web" }}

Node 3 — Airtable (save the lead)

Operation: Create Record
Base ID: your base ID from Step 1
Table: Leads
Fields: map name, email, source, Created (use {{ new Date().toISOString() }})

Node 4 — Slack (notify your team)

Channel: #leads
Message: 🎯 New lead: {{ $('Set').item.json.name }} ({{ $('Set').item.json.email }}) via {{ $('Set').item.json.source }}

Node 5 — Gmail / Send Email (welcome email)

To: {{ $('Set').item.json.email }}
Subject: Thanks for reaching out, {{ $('Set').item.json.name }}!
Body: Write a short, warm reply. Don't make it look automated.

Node 6 — Respond to Webhook

Return: { "status": "ok" }

Connect them 1 → 2 → 3, and from Node 2 also connect to 4 and 5 in parallel (right-click Node 2 → Add Output). Node 6 connects after Node 1 (immediate response) so the form doesn't time out waiting for your CRM writes.

Step 3: Connect your form

In Tally (free):

Add a new block → Redirect / Webhook
Paste your n8n webhook URL
Test submit — you should see the execution appear in n8n immediately

In a plain HTML form:

<form id="lead-form">
  <input name="name" placeholder="Your name" required>
  <input name="email" type="email" placeholder="Email" required>
  <button type="submit">Get started</button>
</form>
<script>
document.getElementById('lead-form').addEventListener('submit', async (e) => {
  e.preventDefault();
  const data = Object.fromEntries(new FormData(e.target));
  await fetch('https://your-n8n.com/webhook/new-lead', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(data)
  });
  // show success message
});
</script>

Step 4: Google Sheets instead of Airtable (optional)

Replace Node 3 with a Google Sheets node:

Operation: Append Row
Spreadsheet ID: your sheet ID from the URL
Sheet: Sheet1
Columns: Name, Email, Source, Created At

Same downstream nodes; everything else stays identical.

The free workflow JSON

Drop a comment below and I'll share the full workflow JSON — import it directly into n8n with File → Import from JSON. It includes all 6 nodes pre-configured with placeholder credentials (swap in yours and it runs).

I've also packaged this workflow alongside two others (Stripe payment fulfillment + form-to-Sheets) into a starter pack if you want all three ready to go:

👉 n8n Workflow Starter Pack — $29 — includes documented JSON + a walkthrough for each workflow.

What to do if the webhook stops receiving data

Two common failures:

Form sends application/x-www-form-urlencoded instead of JSON — add a Code node after the Webhook and parse $input.item.binary manually, or switch your form to JSON mode.
n8n is behind a firewall / localhost — use ngrok to expose it temporarily while testing: ngrok http 5678.

That's the full build. If you're already running this and hit a specific snag, post it in the comments — I check back.

How to save form submissions to Google Sheets with n8n (Tally, Typeform, or plain HTML)

Pirate Prentice — Thu, 25 Jun 2026 10:34:44 +0000

Every form tool promises "connect to Google Sheets" â€” and then charges you $30/month for it. n8n does the same thing in about 15 minutes, free, and you actually own the automation.

Here's how to build a workflow that:

Receives any form submission via webhook
Appends a timestamped row to a Google Sheet
(Optional) fires a Slack alert so your team sees it instantly

Works with Tally, Typeform, Jotform, and plain HTML tags.

Why webhook-based form handling beats native integrations

Native "Sheets integrations" inside form tools are convenient until they're not:

They break when the form tool updates their API
They don't let you transform or filter the data before it hits the sheet
They can't send a Slack alert at the same time
They cost money

With n8n you get one webhook URL that handles everything, and you can add more steps (CRM write, email confirmation, Slack DM) without rebuilding from scratch.

The workflow

Three steps in a straight line:

Webhook -> Normalise payload -> [Google Sheets append]
                           \ [Build Slack message -> Slack post]

The Normalise node handles the fact that Tally, Typeform, and raw POST bodies all structure their payloads differently.

Step-by-step setup

1. Create the workflow in n8n

Add a Webhook trigger node:

Method: POST
Path: form-submit
Response mode: Immediately (no waiting)

This gives you a URL like https://your-n8n-instance.com/webhook/form-submit.

2. Add a Function node - normalise the payload

Different form tools send different shapes:

Tally sends { body: [{ label: "Name", value: "Alice" }, ...] }
Typeform sends { formResponse: { answers: [...] } }
Plain HTML POS sends a flat object directly

const raw = $input.first().json;
let fields = raw.body ?? raw.formResponse?.answers ?? raw.data?.fields ?? raw;

if (Array.isArray(fields)) {
  const flat = {};
  for (const f of fields) {
    const key = (f.label || f.field?.title || f.key || '').trim();
    const val = f.value ?? f.answer?.text ?? f.answer?.label ?? '';
    if (key) flat[key] = val;
  }
  fields = flat;
}

const now = new Date().toISOString();
return [{ json: { ...fields, _submittedAt: now } }];

3. Google Sheets - Append Row

Add a Google Sheets node:

Operation: Append
Document: your sheet ID (from the URL: docs.google.com/spreadsheets/d/THIS_PART/)
Sheet tab: Responses
Column mapping: Auto-map input data

You'll need to connect Google Sheets OAuth2 credentials once - n8n walks you through it.

4. (Optional) Slack alert

const data = $json;
const lines = Object.entries(data)
  .filter(([k]) => !k.startsWith('_'))
  .map(([k, v]) => k + ': ' + String(v).trim());

return [{ json: { blocks: [
  { type: 'header', text: { type: 'plain_text', text: 'New form submission' } },
  { type: 'section', text: { type: 'mrkdwn', text: lines.join('\n') } },
  { type: 'context', elements: [{ type: 'mrkdwn', text: 'Submitted at ' + data._submittedAt }] }
] } }];

5. Configure your form tool

Tally: Settings -> Integrations -> Webhooks
Typeform: Connect -> Webhooks
Plain HTML: set your form action attribute to the webhook URL

6. Test it

Submit a test entry through your form. You should see:

A new row in your Google Sheet with all fields + a timestamp column
A Slack message in your chosen channel

What this handles that native integrations don't

Multi-form fan-out: route different forms to different sheets with an IF node
Data cleaning: strip whitespace, capitalise names, mask PII in the Function node
Error alerting: wire error output to Slack
Chaining: add more steps (Airtable, confirmation email, Trello) without rebuilding

Get the ready-to-import JSON

I'll drop the complete workflow JSON in the comments - import it into n8n and you're five minutes from live.

If you want all three production-ready workflows (this one + a Stripe payment receipt sender + a lead capture/welcome email flow) as a single pack, I keep them at pirateprentice.gumroad.com/l/sxcoe for $29.

Drop a comment if you hit any issues with the Google Sheets OAuth or the payload normaliser - I'm watching.

How to auto-send Stripe payment receipts using n8n (no paid nodes, free workflow)

Pirate Prentice — Thu, 25 Jun 2026 07:32:46 +0000

Stripe's built-in receipts are fine. But the moment you want to send a branded confirmation email, add an order summary, trigger a download link, or write to your own database — you're out of luck without code.

n8n fixes this cleanly. Here's the exact workflow I use to intercept every successful Stripe payment and fire a custom receipt, all with built-in nodes and zero paid integrations.

What the workflow does

Stripe Trigger — payment_intent.succeeded — listens for confirmed payments in real time
HTTP Request — fetch charge details — pulls the full charge object (customer email, amount, description, metadata) via the Stripe API
Set — format receipt data — builds the receipt fields: formatted amount, item name, order ID, timestamp
Gmail / Resend — send receipt email — fires a personalised receipt to the customer email from the charge
Google Sheets — log order — appends a row to your orders sheet (timestamp, customer, amount, order ID, status)
Error — notify on failure — if any node fails, logs to an error sheet and optionally sends you a Slack DM

The whole thing runs in under 2 seconds from payment confirmation to receipt in inbox.

Why not just use Stripe's built-in receipt?

Three reasons I switched:

Branding — Stripe's receipt looks like Stripe's, not yours. Custom email = your logo, your tone, your support link.
Download delivery — if you're selling digital products, you need to attach or link the file in the confirmation. Stripe can't do this natively.
Your own records — the Sheets log gives you a single source of truth you own, outside Stripe's dashboard. Useful for refund tracking, VAT records, or feeding a CRM.

Setup steps

Import the JSON — Workflows → Import from clipboard in n8n
Stripe credential — create a Restricted Key in Stripe dashboard with charges:read and payment_intents:read permissions. Paste into n8n's Stripe credential.
Webhook endpoint — copy the production webhook URL from the Stripe Trigger node. Add it in Stripe Dashboard → Developers → Webhooks → Add endpoint. Select payment_intent.succeeded.
Gmail or Resend credential — connect whichever you use. The email node is pre-wired to {{customerEmail}} from the Set node.
Google Sheets — point the Sheets node at a spreadsheet with columns: timestamp, customer_email, amount, description, order_id, status
Activate — flip the workflow to Active. Every successful payment now triggers the full chain.

Total setup time: under 15 minutes the first time.

The thing most tutorials miss: idempotency

Stripe can fire the same webhook event more than once (retries on timeout, network blips). Without a deduplication check, one payment can generate two receipts and two log rows.

The workflow handles this: before appending to Sheets, it looks up the payment_intent_id in the log. If it already exists, it skips. One receipt per payment, guaranteed.

Get the JSON

Drop a comment below and I'll paste the full workflow JSON. Free to use, MIT-style — import it and adapt it to your setup.

I packaged this workflow alongside two others (Lead Capture → CRM, Form → Sheets + Slack) into a Workflow Starter Pack with full setup docs and test checklists for each. $29 one-time if you want the full set with docs.

What do you use for post-payment automation? Curious what setups others are running.

How I structured 50 legal AI prompts so they are actually reusable

Pirate Prentice — Wed, 24 Jun 2026 23:32:55 +0000

I do a lot of contract drafting, NDA review, and client communication work. Started using AI for it about a year ago. The dirty secret: the quality gap between a bad prompt and a good one in legal work is enormous.

A bad prompt produces generic legalese that needs total rewriting. A good prompt produces a usable first draft. The difference is almost never the model — it is the structure of the ask.

Here is what I figured out.

The core pattern: role + constraints + output format

Every legal prompt that works for me has three parts:

[ROLE]: You are a [practice area] attorney reviewing [document type].
[CONSTRAINTS]: Jurisdiction: [STATE/COUNTRY]. Client type: [INDIVIDUAL/BUSINESS].
Assume: [KEY ASSUMPTION]. Do not: [THING TO AVOID].
[FORMAT]: Output a [FORMAT] covering [SPECIFIC SCOPE]. 
Flag any [RISK TYPE] with a one-sentence plain-English explanation.

The "do not" line does most of the work. Without it, models default to maximally hedged, disclaimer-heavy output. Telling the model what to skip sharpens the response significantly.

The 50 prompts by category

Client intake (8 prompts)

Conflict check memo (takes client name + matter description, flags potential conflicts)
Non-engagement letter (3 variants: conflict, scope mismatch, capacity)
Retainer clause explainer (translates fee language into plain English for the client)
Initial consultation summary

Legal research (9 prompts)

Case summary (input: raw case text, output: issue/holding/reasoning in 200 words)
Jurisdiction comparison (same legal question across two states)
Deposition outline generator
Statute plain-English summary
Counter-argument spotter (reads your draft argument, surfaces the opposing view)

Drafting (10 prompts)

NDA redline reviewer (flags one-sided clauses with explanations)
Contract summary (for clients who will not read the full agreement)
Settlement agreement first draft
Interrogatory response set
Cease and desist (3 tones: firm, aggressive, de-escalating)

Client communication (8 prompts)

Case status update email
Bad news delivery (structure: fact → context → options → next step)
Fee dispute response
Client boundary-setting email

Practice management (15 prompts)

Google Business Profile bio
LinkedIn post series (5 prompts, one per week of content)
SOP draft (input: process description, output: numbered SOP with decision points)
CLE tracker summary
Year-end business review

The most useful single prompt

The contract summary for clients:

You are a [PRACTICE AREA] attorney. A client has asked you to explain this contract 
in plain English. They are [SOPHISTICATED/NON-SOPHISTICATED]. 
Do not use legal jargon. Do not add hedges or disclaimers — 
I will add those separately. 

Summarise the following sections in 2-3 sentences each:
- Parties and purpose
- Key obligations (each party)
- Payment terms
- Termination triggers
- Anything unusual or one-sided

Flag any clause that a [CLIENT TYPE] should negotiate before signing, 
with a one-sentence plain-English reason.

[PASTE CONTRACT HERE]

Clients read this. They do not read a 40-page agreement.

One important note

None of this replaces legal judgment. Every output needs attorney review before it goes anywhere. The prompts are for generating usable first drafts, not final work product.

Full pack of 50 prompts (PDF + Markdown, copy-paste ready with bracket placeholders): https://pirateprentice.gumroad.com/l/sklcrpo ($29 one-time).

If you build legal tech or use AI for your own legal paperwork — what prompts have you found that actually work? Always looking for patterns I have not tried.

40 prompt templates for e-commerce copy (the ones that actually ship)

Pirate Prentice — Wed, 24 Jun 2026 23:32:23 +0000

Most AI copywriting guides give you principles. This is a cheat sheet.

I spent a few weeks building and testing prompts specifically for e-commerce copy workflows — product pages, email flows, ad creative, site copy. The kind of work that fills a freelance pipeline or ships a DTC brand's calendar.

Sharing the architecture here, plus a few samples.

The problem with generic prompts

Generic: "Write a product description for a blue coffee mug."

What ships:

You are a DTC copywriter. Product: [NAME]. Key benefit: [BENEFIT]. 
Target customer: [PERSONA]. Tone: [TONE].
Write a 3-sentence product description opening with the transformation, 
not the feature. No puns. No exclamation marks.

The difference is constraint. Vague inputs produce average outputs. Bracketed placeholders force you to think before you prompt — and that thinking is where the quality comes from.

How the 40 prompts are organised

Product copy (8 prompts)

Feature-to-benefit converter
Long-form PDP (problem → agitation → resolution structure)
Collection page descriptions
Bundle/upsell copy

Email flows (10 prompts)

Welcome series (3-email sequence, single prompt chain)
Abandoned cart 1 (urgency without pressure)
Abandoned cart 2 (social proof + incentive)
Win-back (6-month lapsed customer)
Post-purchase upsell
VIP early access

Ad copy (8 prompts)

Facebook awareness (cold audience)
Facebook retargeting (cart abandoners)
Google search headline set (10 variants)
UGC-style script (15-second video)

Site copy (7 prompts)

Homepage hero (above the fold)
About page (founder story framework)
FAQ generator from product specs
Trust badge copy

Strategy + editing (7 prompts)

Brand voice audit
A/B test variant generator
Brief-to-copy pipeline (PDP + email + 2 FB ads from one input)
Copy critique prompt (gives structured feedback on your draft)

Sample: the brief-to-copy pipeline

This one prompt generates coordinated copy across four formats from a single product brief:

Product brief:
- Product name: [NAME]
- Category: [CATEGORY]
- Key benefit: [BENEFIT]
- Target customer: [PERSONA, age, job, pain point]
- Price point: [PRICE]
- Differentiator vs. competitors: [DIFFERENTIATOR]
- Tone: [TONE]

Using this brief, produce:
1. A 120-word long-form product page description (hook → benefit → social proof placeholder → CTA)
2. A 3-email welcome sequence (subject + 150-word body each)
3. Two Facebook ad variants (hook + 3 body sentences + CTA each): 
   one benefit-led, one pain-led
4. One 15-second UGC-style video script

The output isn't always perfect. But it's a solid first draft across all four formats in one pass — which is the point.

A note on review

Every prompt output needs a human pass. The bracket system forces you to think before generating, but the editing step is where your judgment adds value. These are starting points, not finished copy.

The full 40-prompt pack is available here if you want the complete set: https://pirateprentice.gumroad.com/l/uhckix ($24 one-time, PDF + Markdown).

What copy format do you find hardest to prompt effectively? Curious whether email flows or ad copy is more of a pain point.

I keep rebuilding the same n8n workflows so I documented them (free JSON inside)

Pirate Prentice — Wed, 24 Jun 2026 23:27:51 +0000

Every time I start a new project that needs any kind of lead capture, I spend an hour rebuilding the same n8n workflow. Webhook receiver, email validation, Google Sheets append, welcome email. Every. Single. Time.

So I finally sat down and documented three of them properly — error handling, duplicate detection, null-safe field parsing, the works. Sharing the first one free here.

Workflow 1: Lead Capture → Google Sheets CRM → Welcome Email

This one handles the full lead intake loop:

Webhook — New Lead — receives a POST from any source (Typeform, Tally, plain HTML form, whatever)
Validate & Normalise — trims whitespace, lowercases the email, checks it matches a basic regex before anything else runs
Google Sheets — Append Lead — checks for duplicates first (lookup by email), only appends if new
Gmail — Welcome Email — sends a personalised welcome using the name field from the webhook payload
Error — Notify — if anything in the chain fails, logs to a separate error sheet and optionally pings a Slack channel

All built-in nodes. Zero paid integrations required.

Why I bother with the validation step

Most tutorials skip it. The problem: if you let garbage through to Sheets, you end up with rows like undefined@undefined.com or as a name, and your welcome email looks broken. The validate step costs one extra node and saves hours of cleanup.

The duplicate check is the other thing people skip. Without it, a lead who submits twice gets two welcome emails. Small thing, looks unprofessional.

Setup (under 10 minutes)

Import the JSON into n8n (Workflows → Import from clipboard)
Connect your Google Sheets credential — point it at a sheet with columns: timestamp, name, email, source
Connect your Gmail credential (or swap to SMTP/Resend if you prefer)
Activate the webhook and grab the production URL
Point your form POST action at it

That is it. The workflow handles the rest.

The JSON

Drop a comment below and I will share the JSON file directly. Happy to paste it in a comment or send via DM.

I also put together a Starter Pack with all three workflows (Lead CRM, Stripe Payment Fulfillment, and Form to Sheets + Slack) plus full setup docs and a testing checklist for each one. If you are tired of rebuilding this stuff from scratch: https://pirateprentice.gumroad.com/l/sxcoe ($29 one-time).

What workflows do you find yourself rebuilding most often? Curious what to build next.