I built an RFP/RFQ processor in n8n — watches Gmail for incoming proposals, extracts requirements and evaluation criteria, and alerts your sales team on Slack with deadline urgency

Sales teams miss RFP deadlines not because they’re disorganized, but because the RFP lands in a shared inbox, someone reads it, means to forward it, and it gets buried. By the time the right person sees it, you have 3 days left to write a proposal that needed 2 weeks.

Built a workflow that processes every RFP the moment it hits Gmail. The sales team knows about it within a minute, with all the key details already extracted.

What it does

RFP email arrives in Gmail → downloads the attachment → extracts all requirements and criteria → calculates deadline urgency → logs to RFP tracker sheet → alerts sales team on Slack

Takes about 15 seconds per document.

What gets extracted

Document details:

  • Issuing organization, project title, RFP/RFQ number

  • Submission deadline and submission method

  • Project scope summary

Requirements list:

Every requirement tagged as Required / Preferred / Optional with its category. The Code node counts each type separately so you know upfront how many mandatory items need addressing.

Evaluation criteria with weights:

Pulls each criterion and its percentage weight. Knowing the evaluation breakdown before you start writing changes how you allocate effort — no point spending 40% of your proposal on something worth 10% of the score.

Budget range:

Min and max budget if specified. Formatted as $50,000 - $150,000 or Up to $200,000.

Questions to answer:

Every specific question the RFP requires you to respond to, numbered and listed.

Qualifications and compliance requirements:

Certifications, licenses, and compliance standards required to even bid.

Deadline urgency calculation

The Code node parses the deadline date and calculates days remaining automatically:

  • OVERDUE — already past deadline

  • Urgent — 7 days or fewer

  • High — 8 to 14 days

  • Normal — more than 14 days

This gets logged to the Sheet and shown in the Slack alert so the team knows at a glance which RFPs need immediate attention.

The Slack alert


📋 New RFP Received

Project: IT Infrastructure Modernization

Organization: City of Austin

RFP #: 2025-IT-0042

⏰ Deadline: March 28, 2025

Days Remaining: 11 (High)

💰 Budget: $500,000 - $1,200,000

📝 Requirements:

• Required: 14

• Preferred: 6

• Questions: 8

Evaluation Criteria:

Technical Approach: 40%

Past Experience: 30%

Price: 20%

Team Qualifications: 10%

Sales team sees the evaluation weighting in the alert itself. They know before they open the document that 40% of the score is technical approach.

What lands in Google Sheets

Each row: RFP Number, Project Title, Organization, Deadline, Days Remaining, Urgency, Budget Min, Budget Max, Required Items, Total Requirements, Questions to Answer, Source Email, Received Date, Status

Status defaults to “New” — update it manually as the proposal progresses (In Progress, Submitted, Won, Lost).

Setup

You’ll need:

  • Gmail account (where RFPs arrive)

  • Google Sheets (free)

  • n8n instance (self-hosted — uses PDF Vector community node)

  • PDF Vector account (free tier: 100 credits/month, roughly 25-30 RFPs)

  • Slack (optional — delete the last node if not needed)

About 15 minutes to configure.

Download

Workflow JSON:

github.com/khanhduyvt0101/workflows

Full workflow collection:

khanhduyvt0101/workflows


Setup Guide

Step 1: Get your PDF Vector API key

Sign up at https://www.pdfvector.com — free plan works for testing. Go to API Keys and generate a key.

Step 2: Set up your Google Sheet

Create a new spreadsheet with these exact headers in Row 1:


RFP Number | Project Title | Organization | Deadline | Days Remaining | Urgency | Budget Min | Budget Max | Required Items | Total Requirements | Questions to Answer | Source Email | Received Date | Status

Copy the Sheet ID from the URL.

Step 3: Import the workflow

Download the JSON from GitHub and import into n8n via Import from File.

Step 4: Configure the nodes

Gmail Trigger:

  • Connect your Gmail account (OAuth2)

  • Watches all incoming email — add a label filter if you want to limit to emails labeled “RFP” or from specific domains

Get a message:

  • Same Gmail credential

  • downloadAttachments: true is already set

PDF Vector - Extract RFP:

  • Add new credential (Bearer Token type)

  • Paste your API key

  • Note: uses attachment_0 as the binary property name — this is correct for Gmail attachments

Analyze RFP:

  • No config needed — deadline parsing and urgency calculation happen automatically

Log to RFP Tracker:

  • Connect Google Sheets

  • Paste your Sheet ID

Alert Sales Team:

  • Connect Slack

  • Paste your sales channel ID

Step 5: Test it

Send yourself a test email with an RFP PDF attached. Wait about 30 seconds and check your Sheet and Slack channel.


Accuracy

Tested on government RFPs, corporate RFQs, and consulting proposal requests.

  • Project title, organization, RFP number: ~97% on digital PDFs

  • Submission deadline: ~94% — handles most date formats including “March 15, 2025 at 5:00 PM EST”

  • Requirements extraction: ~91% — occasionally misses requirements embedded in paragraph text vs. bulleted lists

  • Evaluation criteria with weights: ~88% — works well when criteria are in a table or list, less reliable when weights are described in prose

  • Budget range: ~85% — some RFPs deliberately omit budget or describe it vaguely

Scanned PDFs: drops to ~82% overall. Deadline parsing is most affected.

Cost

Each RFP uses about 3-4 PDF Vector credits. Free tier of 100 credits gets you roughly 25-30 documents per month.

Basic plan is $25/month for 3,000 credits if you’re handling volume.

Customizing it

Add a label filter to Gmail:

In the Gmail Trigger node, add a label filter so it only processes emails tagged “RFP” in your inbox. Prevents the workflow from triggering on every incoming email.

Add urgency-based routing:

Insert an IF node after Analyze RFP to split Urgent vs Normal RFPs into separate Slack channels — one for immediate action, one for regular pipeline.

Track win/loss rate:

Add a column to your Sheet for Outcome (Won/Lost/No Bid) and update it after each RFP resolves. After a few months you’ll have data on which types of RFPs you win most often.

Connect to a CRM:

Replace or supplement the Sheets node with an HTTP Request node to create a deal in HubSpot, Salesforce, or Pipedrive automatically. The extracted fields (organization, budget, deadline) map directly to CRM deal fields.


Limitations

  • Requires self-hosted n8n (PDF Vector is a community node)

  • Watches all Gmail — add label filtering for production use

  • Evaluation criteria weights are only as reliable as how clearly they’re written in the RFP

  • Doesn’t generate the actual proposal — that’s still a human job. This handles intake and analysis only

  • Multi-attachment emails will only process attachment_0 — if the RFP spans multiple files, you’ll need to modify the binary property handling


Links


Questions? Drop a comment if something’s not working or you want to extend it with proposal generation.

1 Like

Really nice workflow. The extraction accuracy numbers are impressive, especially 97% on project titles. Processing RFPs in 15 seconds instead of having someone manually read through each one is a massive time saver.

One thought on the CRM integration you mentioned at the end (replacing Sheets with
HubSpot/Salesforce/Pipedrive via HTTP Request): you might want to look at a CRM that has a native n8n community node instead. That way you skip the HTTP Request setup entirely and just drop in a CRM node the same way you’d use the Gmail or Slack node.

A few options that have n8n nodes: HubSpot (built-in), Pipedrive (built-in), Twenty CRM (community node, open-source), or Customermates (community node, open-source, self-hostable). Full disclosure, I built Customermates, so take that with appropriate bias. But the reason I built the n8n node first was exactly this use case: workflows that generate structured data (like your RFP extractions) and need a proper place to land that isn’t a spreadsheet.

The advantage over Sheets for this specific workflow: once an RFP creates a deal in a CRM, you get pipeline stages (received, evaluating, bid submitted, won/lost), assignment to team members, follow-up reminders when deadlines approach, and a single view of all active bids. Sheets can technically do some of that but it gets messy fast once you have 20+ active RFPs.

Either way, cool build. The PDF Vector community node is one I hadn’t seen before.