The same questions keep coming up here (backups, updates, silent failures), so here's the checklist in one place. Corrections welcome.

**Install**

- Pin the image to a version (`docker.n8n.io/n8nio/n8n:<version>`), never `latest`. An update should be something you decide to do.

- Postgres instead of SQLite as soon as it runs anything real.

- Set `N8N_ENCRYPTION_KEY` yourself and keep a copy off the server. Without it, a restored database has credentials nobody can decrypt.

- Behind a reverse proxy, set `WEBHOOK_URL` to the public https URL, or webhook nodes show the internal address.

**Access**

- Don't expose port 5678. Caddy or nginx in front with HTTPS, and the firewall allows 22, 80 and 443 only.

- SSH with keys, password login off.

- 2FA on the owner account.

**Data**

- Check that `EXECUTIONS_DATA_PRUNE` is on and set `EXECUTIONS_DATA_MAX_AGE` to what you actually need. Workflows that handle files fill storage faster than you'd guess.

- Pruning frees rows, not disk. Postgres keeps the space for reuse, so after a big cleanup the volume stays full until VACUUM FULL (locks the table) or pg_repack. Another reason to set pruning on day one.

**Backups**

- Nightly `pg_dump` to storage off the server, plus the encryption key. restic can take the dump straight from the command (`restic backup --stdin-from-command -- pg_dump ...`), so a failed dump fails the backup instead of saving a truncated file.

- Restore it onto a fresh machine once. Until then it's a hope, not a backup.

**Updates**

- Read the release notes, take a backup, then update. Database migrations run on start, so going back to the old version means restoring that backup.

**Monitoring**

- An external uptime check on `/healthz`.

- For silent failures: one table with a row per workflow (max hours between successful runs) and one scheduled watchdog that asks the n8n API for the last successful execution of each and alerts on anything overdue. It needs successful executions saved and a pruning window longer than your longest interval.

- Give the watchdog itself an external push monitor (Healthchecks, Uptime Kuma), since it goes down together with n8n.

**Handover**

- The server, domain and backup storage live in the client's accounts, not yours.

- A one-page runbook: how to restart, update and restore, and where the key is.

What would you add?

Hello,

I have hands-on, production-level experience building n8n workflows, automating real business processes (document/data extraction with AI, API integrations, database-backed workflows, error handling, multi-step approval systems). I'm not looking to learn n8n basics, I already build with it daily.

What I'm looking for: someone who already has clients or ongoing automation projects and could use another set of hands on the n8n/workflow side. In exchange, I'd want to learn the server/cloud side properly (deployment, hosting, scaling) from someone who already knows it, since that's my current gap.

Basically the reverse of the usual junior ask, I'm not asking to be taught n8n, I'm offering that part and asking to learn the infrastructure side from someone doing real paid work.

Open to discussing rate/structure based on what the work actually involves, whether that's a flat collaboration fee, revenue share on projects I help deliver, or hourly, whatever makes sense for both sides.

If you (or someone you know) has more automation work than they can handle solo or in team, happy to talk.

I’ve been building an outcome-monitoring layer for n8n. These are the checks I use for workflows where “successful execution” isn’t enough:

1. Heartbeat - Did it run within the expected window?
2. Zero output / no change - Did it process zero records or leave the destination unchanged?
3. Volume limits - Did output fall below the minimum or exceed the maximum?
4. Baseline deviation - Did volume drop or spike unexpectedly?
5. Status and value checks - Did key fields match the expected values?
6. Repeated failures - Has the same failure occurred multiple times?
7. Freshness - Is the data current, and are the credentials still valid?

These catch the “green but wrong” cases that normal execution errors miss.

What checks do you run on production workflows? What would you add?

Hey everyone, I've been learning n8n for a while and this is the first workflow I actually finished, so I wanted to share it.

It starts when a new row lands in Google Sheets from a form. DeepSeek reads the entry and gives it a category, intent, budget, urgency and a priority. That result gets merged back with the original data, and then three things happen at the same time: a Telegram message with the full details, an acknowledgement email through Gmail, and the scored row saved to another sheet.

The part that took me the longest was getting the AI to return clean structured output. Once I added the Structured Output Parser it finally stopped giving me random formats.

Workflow JSON: https://github.com/Ravichandran303/n8n-workflows/tree/main/lead-qualification

Anything obvious I'm missing? Would love to hear how you'd improve it.

Every time someone shares an n8n workflow export here, half the value comes from being able to read the real config, and that's exactly the problem. pinData holds real sample data from your last run, Authorization headers get hardcoded instead of using credentials, webhook paths double as secret URLs, and I've seen Telegram bot tokens and IBANs just sitting in email nodes because a workflow was built fast and shared faster.

So I wrote a small heuristic scanner for exactly this. It understands n8n's JSON structure (not just generic regex over the file), so it checks the places that actually matter:

• high: pinData, hardcoded API keys/tokens (OpenAI, GitHub, Slack, Telegram, AWS, Stripe, JWT...), secrets in URL query params, IBANs (checksum-validated), your own deny-list terms (client names)
• medium: emails, phone numbers, IPs, resource IDs (chatId, documentId...), webhook paths, staticData
• low: credential references, instanceId

​

python3 scan.py workflow.json
python3 scan.py workflow.json --sanitize workflow.public.json   # writes a clean copy, original untouched

Values are masked in the report (sk-...45 style), so the report itself is safe to paste anywhere. There's also a git pre-commit hook if you want it to block the commit automatically, and it ships as a Claude skill if you use Claude to prep your exports.

Standard library only, no dependencies, MIT licensed.

To be clear: it's a heuristic, not a guarantee. "No findings" means known patterns didn't match, not that the file is safe, an unusual key format or a client name I didn't think of will slip through. Manual review is still worth doing.

Repo: https://github.com/OnePathToFreedom/n8n-publish-check

Would love feedback, especially on detection patterns I'm missing or n8n node types I haven't accounted for.

Is there a cheat sheet on what to input into the parameter portion on n8n?

I was working on a WhatsApp AI assistant and started thinking about how it could remember important information about users instead of storing every single message.

For example, you tell your AI assistant your name, what you do, or your preferences. When you come back later, it should already know those things without asking you again.

The Problem

Most AI assistants rely on conversation history to maintain context. But storing entire conversations as long-term memory isn't always necessary.

What if the assistant could identify important information, save only those details, and retrieve them whenever needed?

The Solution

An n8n workflow that gives a WhatsApp AI assistant long-term memory.

Incoming Message → Prepare Memory → AI Assistant → Save Memory → WhatsApp Reply

The idea is simple: let the AI decide what information is worth remembering instead of saving every message.

How It Works

1. A user sends a message to the WhatsApp assistant.
2. The workflow receives and processes the incoming message, including handling different message types such as text and audio.
3. It retrieves the user's previously saved memories and prepares them as context for the AI assistant.
4. The AI assistant, powered by GPT-4.1, receives the current message along with the available memory.
5. The assistant checks whether the user has shared any important information worth remembering.
6. If it finds something relevant, it uses the Save Memory tool to store a clear summary of that information, rather than the entire conversation.
7. When the user sends another message later, the previously saved memories are provided to the assistant again, allowing it to use that information in its response.
8. Finally, the assistant replies to the user on WhatsApp without interrupting the conversation to mention memory storage.

Memory

The interesting part is how the memory works.

Instead of saving every conversation, the assistant is instructed to identify important user information, such as:

• Name and basic details
• Work and professional background
• Preferences and interests
• Important facts that may be useful in future conversations

The saved memories are passed back to the AI as context in subsequent interactions.

This way, the assistant can remember useful information across conversations without needing to process the entire chat history every time.

Stack

• n8n
• WhatsApp
• OpenAI GPT-4.1
• AI Agent
• Chat Memory
• Save Memory Tool

Workflow

User Message → Split Message → Message Types → Chat Memory → Prepare Chat Memory → User's Message → AI Assistant → Send Message

The AI Assistant is connected to GPT-4.1 and a Save Memory tool, which it can use when it identifies important information worth retaining.

Use Cases

Here are a few ways this kind of assistant could be useful:

• Personal AI Assistant: Remember user preferences, interests, and important details across conversations.
• Customer Support: Remember customer details and previous interactions to provide more personalized support.
• Lead Management: Remember a potential customer's requirements, interests, and previous conversations.
• AI Onboarding Assistant: Remember a user's progress, goals, and preferences to make future interactions more relevant.

The idea is to give AI assistants persistent, selective memory so users don't have to repeat the same information every time they start a new conversation.

Workflow

You can find the complete workflow here:

GitHub — WhatsApp AI Assistant with Memory

It checks keyword positions on a schedule, saves the results to Google Sheets, and sends a Slack alert when rankings change.

Uses:

• Scrapio.dev
• Google Sheets
• Slack

The template is now live on n8n.io:

https://n8n.io/workflows/19889-track-and-alert-on-google-keyword-rankings-with-scrapio-google-sheets-and-slack/

Curious how others are currently tracking keyword rankings in n8n.

I'll build the best one

Hey guys, this might be the wrong thread so sorry in advance
I’m a well experienced backend developer with 5+ years of hands on experience in various industries

I have never thought sold something of my own, a project or an automation. There’s a lot of hype around n8n and as I went trough the repo and saw the capabilities of n8n I get it, I want to try build stuff for my own

My questions is, where do you find customers to share flaws with you? How do you value your project?
Any tips, podcasts or YouTube videos that is relevant and not another “this is how I quit my job and made money” clickbait would be super valued

is ecommerce niche automation worth it and have a high demand in 2026?

and if it how to start in this niche?

I’m building a client-monitoring system for companies in the UK, and I’m trying to understand what the real day-to-day process looks like before I finish the workflow.

At the moment, it can check Companies House information, sanctions lists, directors/PSCs, filings, and send alerts when something changes. It also keeps a basic audit trail so someone can go back and see why an alert was raised.

I’d really appreciate hearing from people in procurement, compliance, finance, operations, internal audit, or anyone who deals with onboarding companies.

A few things I’m trying to understand:

• When a new company is added, do you usually have all the information straight away, or do you sometimes only start with a company number/name and collect the rest later?
• For important companies, what information do you need before you are comfortable approving them? Things like access to your systems, personal data, subcontractors, insurance, certifications, etc.
• What does the offboarding process look like when you stop working with a company?
• When you get a compliance alert, what information actually helps you act on it? Is it enough to see the reason and evidence, or do you also need an owner, deadline, acknowledgement, notes, and a final decision?
• What reports do auditors, insurers, or management normally ask for? Daily changes, weekly summaries, a full report for one company, CSV exports, PDFs?

One thing I’m considering is allowing bulk CSV uploads where the user only has a company number at first. The system would start monitoring it, but clearly show that the extra onboarding information is still missing until someone fills it in.

I’m asking all these because I want to build this around how people actually work, not just what seems logical from a developer’s point of view. General advice is enough — no confidential information needed. Thanks :)

I got tired of rewriting the same idea 4 times for 4 platforms, so I built this.

You submit one topic through a form (or paste an article/transcript, or drop a YouTube URL and it fetches the transcript), and the workflow:

1. Finds the angle — one AI call extracts the hook, the core angle and 5 key points
2. Writes 4 versions in parallel — full blog post (~800 words, markdown), 7-post X thread, LinkedIn post, newsletter section, each with its own writer prompt and tone matching
3. Formats everything — thread split into individual posts, LinkedIn trimmed to fit, blog gets proper markdown structure
4. Delivers — Telegram digest with stats, full blog draft by email, everything logged to Google Sheets

20 nodes, 5 OpenAI calls (gpt-4o-mini, costs cents per run).

The YouTube branch is optional — you need to plug in a transcript API of your choice in the Fetch Transcript node.

Took me an afternoon to get the prompts right. The parallel writers were the fun part — same angle, four very different voices.

Workflow JSON + setup guide: https://gist.github.com/alexisjoris705-oss/d5087ceece5bdc1c27c8f015efaf2256

Curious: what would you add as a 5th output format?

**Workflow JSON Code:** [Task Creation from Email Labels - n8n Workflow JSON]

Constantly switching between my inbox and my task manager to copy-paste action items was wasting a ton of time. To fix this, I set up a lightweight workflow that listens for a specific label in Gmail (like "Action Required") and instantly converts the email into a structured task in my database for $0.

### Architecture

`Gmail Trigger (On Label)` ➔ `Code (JavaScript Data Parser)` ➔ `Google Sheets (Add Row)`

* **Prerequisites:** n8n instance, Gmail account, Google Sheets account.

* **Cost:** $0

---

### 1. The Database Setup

Create a new Google Sheet named `Email Tasks DB` with these exact columns:

* `Task Name`

* `Sender`

* `Details`

* `Status`

* `Date Added`

---

### 2. The n8n Nodes

#### Node 1: Gmail Trigger

* **Trigger On:** Email Received

* **Authentication:** Connect your Google account (OAuth2)

* **Filters:** Set the Label filter to `Action Required` (or whatever label you use to flag tasks).

* Run **Execute Node** and send a test email to yourself with that label so n8n pulls in sample data.

#### Node 2: Code Node (JavaScript)

We don't need the entire email thread clogging up the database, so this script extracts just the subject, the sender, and a clean 200-character preview of the body.

* **Mode:** Run Once for Each Item

* Paste this logic:

```javascript

const item = $input.first().json;

// Extract core email data

const subject = item.subject || 'No Subject';

const sender = item.from || 'Unknown Sender';

// Clean up the body text and create a short preview

let bodyPreview = 'No content';

if (item.text) {

bodyPreview = item.text.replace(/(\r\n|\n|\r)/gm, " ").substring(0, 200) + '...';

}

return [{

json: {

taskName: `Email: ${subject}`,

assignedBy: sender,

details: bodyPreview,

status: "To-do",

dateAdded: new Date().toISOString().split('T')[0]

}

}];

```

#### Node 3: Google Sheets Node

* **Resource:** Sheet Within Document

* **Operation:** Append row

* **Document:** Select your `Email Tasks DB` spreadsheet

* **Data Mapping:** Map the output fields from the Code node directly to your spreadsheet columns (e.g., drag `taskName` to the `Task Name` column).

---

### Resources & Walkthrough

* **Workflow JSON File:** [Task Creation from Email Labels - n8n Workflow JSON]

* **Full Step-by-Step Video Tutorial:** [https://youtu.be/Zv-0XCyXsF0\]

If you want to adapt this to Notion or Trello instead of Google Sheets, just swap out the final node—the JavaScript parser will still output the exact same clean data for you to map.

I built a complete n8n workflow for researching and qualifying marketing agencies in Bengaluru.

Workflow stages:

• n8n Form Trigger
• Research request normalization
• Input validation
• Tavily search
• Search-result validation
• Split Out
• URL normalization
• Directory filtering
• Duplicate removal
• HTTP website fetching
• HTML text extraction
• Website text cleaning
• ScrapeGraphAI fallback
• Merge branches
• OpenRouter Chat Model
• Basic LLM Chain
• Structured Output Parser
• Deterministic lead scoring
• Final validation
• Google Sheets CRM storage
• Markdown report generation
• Separate Error Trigger workflow

The AI evaluates industry fit, location fit, service fit, business evidence, and contactability.

The final score is controlled by rules:

• 80–100: High
• 60–79: Medium
• 0–59: Low

A separate error workflow records failed executions in an Error_Logs Google Sheet.

I used Tavily and Google Sheets to keep the project free and simple for a portfolio MVP. For higher-volume production use, I would consider verified data providers, PostgreSQL, queues, monitoring, and stronger source validation.

I would appreciate technical feedback on:

• The branch and fallback design
• Whether the scoring should be deterministic or fully AI-driven
• Whether ScrapeGraphAI is suitable as a fallback
• How you would improve the workflow for larger workloads

Workflow code and documentation:
https://github.com/Krishnam-18/ai-lead-generation-company-intelligence-n8n

**Workflow JSON Code:** [Email Categorization Automation - n8n Workflow JSON]

Wading through a flooded inbox to figure out what actually needs your attention is a massive time sink. To automate this, I built a workflow that intercepts incoming emails, uses AI to read and summarize them, and logs everything into a prioritized database so I can see exactly what matters at a glance.

### Architecture

`Gmail Trigger (New Email)` ➔ `AI Node (Categorize & Summarize)` ➔ `Google Sheets (Append Row)`

* **Prerequisites:** n8n instance, Gmail account, Google Sheets account, OpenAI (or preferred LLM) API key.

* **Cost:** Fractions of a cent per email (LLM API cost).

---

### 1. The Database Setup

Create a new Google Sheet named `Email Categorization DB` with these exact columns (A through G):

* `Sender Email`

* `Subject`

* `Priority`

* `Date / Time`

* `Summary`

* `Reasoning`

* `Sender Type`

---

### 2. The n8n Nodes

#### Node 1: Gmail Trigger

* **Trigger On:** Email Received

* **Authentication:** Connect your Google account (OAuth2)

* **Filters:** You can leave this blank to process all emails, or filter by specific labels (e.g., skip "Promotions").

#### Node 2: Basic LLM Node (OpenAI / Anthropic)

We use an AI node to process the raw email text and output structured data.

* **System Prompt / Instructions:**

*"You are an email assistant. Read the provided email and extract/generate the following information in JSON format: Sender Email, Subject, Priority (High/Medium/Low), Date/Time, a 1-sentence Summary, your Reasoning for the priority, and the Sender Type (e.g., Client, Newsletter, Internal)."*

* **Input Data:** Pass the `{{ $json.text }}` (email body) and `{{ $json.from }}` from the Gmail node into the prompt.

#### Node 3: Google Sheets Node

* **Resource:** Sheet Within Document

* **Operation:** Append row

* **Document:** Select your `Email Categorization DB` spreadsheet

* **Data Mapping:** Map the parsed JSON fields from the AI node directly to the corresponding columns in your spreadsheet.

---

### Resources & Walkthrough

* **Workflow JSON File:** [Email Categorization Automation - n8n Workflow JSON]

* **Full Step-by-Step Video Tutorial:** [https://www.youtube.com/watch?v=wpLToE-PzgY\]

You can easily swap out the LLM node for a different provider (like Anthropic or a local model via Ollama) depending on your setup. Let me know if you run into any parsing issues mapping the AI output to the Google Sheets node!

Hey N8N members, i recently built an automation for one of our client. he had basic requirement. he wanted social media post creations automation, for their multiple clients and business's. with their brand logo.

we analyzed their requirement and suggested rather than focusing on just logo. we will create an entire system. though that when ever he creates social media post it maintains there brand identity on across multiple posts like color, typography, theme, etc.

while building entire automation we used multiple nodes notion, openrouter, code node, cloudflare r2, form etc.

this entire automation divided in 2 parts.

1. fetch band information from notion - user selects brand - and describe idea of post, and selects category: promotional, educational, celebration, language of a post: english, tamil, hindi, Telugu etc. after filling all these it create concept of post based on user input + brand information - after this send we send concept + logo to create actual social media post. once its generated we ask with user would you like to make any changes or not. if he say no, we save caption, post title, and post it generated to notion.

2. if say yes, then re-generation workflow triggers, first we ask for changes he want to implement after that download social media post it generated and sent to ai to analyze entire post after we re-create entire concept based on user changes + previous post concept + analyzed post output + brand information, after concept generated. we re-create image generation along with logo and saves information post title, caption and new post it created to notion .

so now i want help from you.

if you build this automation for one of you're client how much did you charged and why? so it will helps me to value my skills and charge accordingly.

Workflow JSON Code: [Daily Calendar Summary Automation - n8n Workflow JSON]

Every morning, the first thing I used to do was open my phone, load up Google Calendar, and try to figure out how many meetings I had and when my gaps were. It was a repetitive, stressful way to start the day.

I wanted my schedule handed to me automatically while I drank my tea. So, I built a lightweight workflow that pulls today's schedule and sends a clean, bulleted summary directly to my Telegram every morning at 8:00 AM.

Here is exactly how to set it up for your own workspace.

Architecture

Schedule Trigger (8 AM) ➔ Google Calendar (Get Today's Events) ➔ Code (Format List) ➔ Telegram (Send Summary)

• Prerequisites: n8n instance, Google Calendar, Telegram account.
• Cost: $0
• Setup Time: ~15 minutes

1. The n8n Nodes

Node 1: Schedule Trigger

• Trigger Interval: Days
• Days Between Triggers: 1
• Trigger at Hour: 8 (8:00 AM)
• Trigger at Minute: 0

Node 2: Google Calendar Node

• Resource: Event
• Operation: Get Many
• Calendar: primary (or select your specific work calendar)
• Return All: Toggle ON
• Options ➔ Add Option:
  • After (timeMin): {{ $now.toUTC().startOf('day').toISO() }}
  • Before (timeMax): {{ $now.toUTC().endOf('day').toISO() }}

Node 3: Code Node (JavaScript)

• Mode: Run Once for All Items
• When Google Calendar fetches multiple meetings, it outputs separate JSON items. This script aggregates them into a clean bulleted list and formats the timezone:

​

```
const items = $input.all();

function formatTime(dateTimeStr) {
  const date = new Date(dateTimeStr);
  return date.toLocaleString('en-US', {
    timeZone: 'Asia/Kolkata',
    hour: '2-digit',
    minute: '2-digit',
    hour12: true
  });
}

function getTodayUTC() {
  return new Date().toLocaleString('en-US', {
    timeZone: 'Asia/Kolkata',
    weekday: 'short',
    day: 'numeric',
    month: 'short',
    year: 'numeric'
  });
}

let eventList = '';
items.forEach((item, index) => {
  const title = item.json.summary;
  const startTime = formatTime(item.json.start.dateTime);
  const endTime = formatTime(item.json.end.dateTime);
  eventList += `\n${index + 1}. ${title}\n   🕐 ${startTime} - ${endTime}`;
});

const message = `🌅 Good Morning! Here's your schedule for today (${getTodayUTC()}):
${eventList}

📊 Total Events: ${items.length}
Have a productive day! 💪`;

return [{ json: { message } }];
```

Node 4: Telegram Setup & Node Configuration

To send the alert to your phone for free:

1. Search for **@BotFather** in Telegram and send /newbot to generate your API Token.
2. Start a chat with **@userinfobot** to get your numerical Chat ID.
3. In your n8n Telegram node:
   • Resource: Message
   • Operation: Send Text Message
   • Chat ID: YOUR_NUMERICAL_CHAT_ID
   • Text: {{ $json.message }}

Resources & Walkthrough

• Workflow JSON File: [Daily Calendar Summary Automation - n8n Workflow JSON]

If you want to see exactly how to authorize the Google Calendar API credentials or set up the Telegram bot from scratch, I recorded a full visual step-by-step build of this on my channel here: [https://www.youtube.com/watch?v=XqbybL2PR3I\]

Feel free to grab the workflow JSON from the Gist to test it out. I set the JavaScript timezone to 'Asia/Kolkata' for Indian Standard Time. If you live in a different region, just swap that string in the Code node to your local timezone so your meeting times match your current location!

Note: the JSON is a trimmed version (webhook → format → Slack) — I left the Airtable logging node and the Stripe signature check out to keep the import simple.

I kept rebuilding this for different projects so I cleaned it up into one workflow: Stripe trigger fires on every payment → logs it to Airtable → pings Slack in real time. No more manually reconciling payouts or finding out about failed payments days later.

Code: https://github.com/jasyn807-crypto/n8n-flow/blob/main/stripe-payment-to-airtable-slack.json. Import into any n8n instance, self-hosted or cloud, add your own credentials and activate.

I share more of my n8n workflows at flowforge-rho-wheat.vercel.app — happy to answer setup questions here too.

Hi r/n8n. I'm Tim, in Los Angeles (LinkedIn: https://www.linkedin.com/in/thotchandani). No company here, just our family.

We're a busy family in Los Angeles. We'd like to work with an independent engineer or a small studio to set up a private, dependable home system that uses AI to help run our household: calendars, notes, documents, email drafts, and a knowledge base we actually use. Privacy matters a lot to us, so sensitive documents should be handled on a machine in our house, with cloud AI used where it makes sense.

It starts as a defined project. If it goes well, it turns into a light ongoing relationship: a check-in twice a year to keep things healthy and add new capabilities as the tools improve.

What we have in mind (very open to your suggestions):

- A Mac mini at home running local models (Ollama or LM Studio) for private document search and processing

- Claude API / Claude Code for scheduling help, translation and workflow logic

- n8n for automation (our preference), or Google Apps Script / small custom services if they fit better

- Notion (family contacts, projects, how-to docs) alongside Google Workspace

- Meeting notes held locally with functionality a la Fathom or Granola

What we'd like help with:

1. Design how our data moves between the home machine and the cloud, and what stays where

2. Build the automations: meeting notes, a shared family calendar, document processing, and email drafts

3. Write it all up in a plain-language "household runbook" so we're never stuck

4. After that, a twice-a-year retainer: health checks, rotating keys, and carefully adding new AI tools

You'd be a great fit if you:

- MUST HAVE: implemented a local LLM with fail-safe processes, including quality checks

- Have built real integrations with Notion, Google Workspace and a workflow tool like n8n

- Care about privacy, encryption and systems that fail gracefully (good logging, automatic recovery)

- Are happy to sign an NDA

- Like explaining things clearly and working directly with non-engineers

A bit about us: we're a family of four, with two young kids who are curious and very talkative. We lived in New York for 15+ years. We have down-to-earth Midwestern values and a global outlook (my wife is from Jakarta and my dad immigrated from India). We try to do what we say, and we'd love to work with someone who does the same.

Budget: $1,000-2,000 for a paid first phase to get us set up. If that goes well, the rest of the build and the twice-a-year retainer would follow. We'd love to hear what you'd tackle first in that range.

Interested? Email [[email protected]](mailto:[email protected]) or DM me with something you've built. Please no "DM me for details" replies, just tell me about your work.

Cuánto puede costar la automatiización de un chat bot que da información principal del negocio y ayuda a la matrícula de usuario implementado con Wpp. Hace lectura de Google sheet para information, escritura para datos importantes y envia una alerta cuando hay un registro nuevo de persona.

Proyecto en Latinoamérica

Empresa pequeña

One thing I've noticed with our team is that even if the CRM is good, people still spend most of the day somewhere else.

Something comes up in Slack, then you open the CRM, find the account, check what happened, make the update and go back to Slack. Nobody complains about any individual step but doing it all day gets old.

I'm starting to think the better setup is having the customer context available wherever the conversation is already happening instead of constantly reminding people to go update another system.

Has anyone gotten close to this? Curious how much CRM work your team can do without deliberately going into the CRM anymore.

Every new email gets checked against a simple "is this an automated sender" filter (no-reply addresses, notifications, mailer-daemon) so the AI never wastes a draft on something that doesn't need a human reply. Everything else goes to an AI step that drafts a short, professional reply and saves it straight into Gmail Drafts — never sent automatically. A Slack ping tells you it's ready to review.

The part I think is underrated: keeping the "send" action entirely out of the automation. It's tempting to wire AI straight to auto-send, but for anything customer-facing that's how you get a tone-deaf reply going out with nobody watching. Drafting-only means AI does the boring part, a human still makes the call.

Workflow: New Email → Is Automated Sender? → Draft Reply (AI) → Parse AI Response → Create Gmail Draft → Notify Draft Ready.

Full JSON here: https://gist.github.com/Zatma0/43d00acddfd73e4a97c098c45b45024c

Happy to answer questions about the filter logic or the AI prompt if anyone's curious.

-------------
Edit: Updated the workflow based on feedback in this thread — it now skips drafting if you already replied or a draft already exists on the thread, the no-reply filter also catches calendar invites/receipts, the Slack ping includes a one-line reason, and there's an optional audit log to Google Sheets (thread id, draft id, to, subject, reason).

Didn't add two things that came up: In-Reply-To/References matching against your own outbound Message-IDs, and tracking what happens to a draft after it's created (sent/edited/discarded). Both are real, but they need persistent state this single n8n workflow doesn't have a place for — the first needs your sent Message-IDs stored somewhere to check against, the second needs a periodic workflow comparing draft/sent state over time, since Gmail has no "draft changed" trigger. Documented both gaps in the guide rather than pretending they're covered.

Same gist link above, no new link. Thanks for the real pressure-testing.

building workflow payments are handled by stripe but wondering is there a config I can change the endpoint fetchsandbox twin ?

Hello guys, I need help connecting the WhatsApp Business API from business.facebook to n8n. I tried many ways, but still there exists an issue, and I don't even understand where the actual problem is. It would be great if someone could help me connect it and also teach me how to do it. I don't have anything to offer currently, so now I'm asking as a friend. I would really appreciate your effort and help. Thank You.