AI Quote/Estimate Follow-Up

You sent the quote. Now what? Most quotes die in silence because follow-up is awkward and inconsistent. AI makes it systematic and effective.

The Quote Follow-Up Problem

System Architecture

┌─────────────────────────────────────────────────────────────┐
│               Quote/Estimate Sent                            │
│         (Manual entry or CRM trigger)                        │
└───────────────────────┬─────────────────────────────────────┘
                        │
                        ↓
┌─────────────────────────────────────────────────────────────┐
│              Quote Follow-Up Sequence                        │
│                                                              │
│   Day 2: "Did you receive the quote?"                       │
│   Day 4: "Any questions I can answer?"                      │
│   Day 7: "Where are you in the decision?"                   │
│   Day 10: "Here's what other customers say..."              │
│   Day 14: "Ready to move forward?"                          │
│   Day 21: "Quote expires soon"                              │
└───────────────────────┬─────────────────────────────────────┘
                        │
              ┌─────────┴─────────┐
              ↓                   ↓
        [Response]          [No Response]
              │                   │
              ↓                   ↓
┌──────────────────┐    ┌──────────────────┐
│ AI Handles:      │    │ Long-term:       │
│ • Questions      │    │ • Monthly check  │
│ • Objections     │    │ • Seasonal offers│
│ • Negotiation    │    │ • Re-quote       │
│ • Closing        │    │                  │
└──────────────────┘    └──────────────────┘

Step-by-Step Implementation

Step 1: Quote Tracking Setup

Create custom fields in GoHighLevel:

const quoteFields = {
  quote_number: "string",
  quote_amount: "number",
  quote_date: "date",
  quote_expiry: "date",
  quote_status: "dropdown", // sent, viewed, accepted, declined, expired
  quote_items: "text", // JSON of line items
  follow_up_count: "number",
  last_follow_up: "date",
  objections_raised: "text", // JSON array
};

Step 2: Trigger Quote Sequence

n8n Workflow Trigger:

// Trigger options:
// 1. GHL opportunity stage changes to "Quote Sent"
// 2. Webhook from quoting software (PandaDoc, Proposify)
// 3. Manual tag addition

const quoteData = {
  contactId: $input.item.json.contactId,
  quoteNumber: $input.item.json.quoteNumber,
  quoteAmount: $input.item.json.amount,
  quoteSentDate: new Date().toISOString(),
  expiryDate: addDays(new Date(), 30),
  lineItems: $input.item.json.items,
  salesRep: $input.item.json.assignedUser,
};

// Calculate follow-up schedule
const followUpSchedule = [
  { day: 2, type: "receipt_confirmation" },
  { day: 4, type: "questions_check" },
  { day: 7, type: "decision_status" },
  { day: 10, type: "social_proof" },
  { day: 14, type: "soft_close" },
  { day: 21, type: "urgency" },
  { day: 28, type: "expiry_warning" },
];

// Store schedule
await updateContact(quoteData.contactId, {
  quote_follow_up_schedule: JSON.stringify(followUpSchedule),
  quote_sequence_active: true,
});

Step 3: Create Quote-Specific AI Prompts

const quoteFollowUpPrompt = `You are following up on a quote for ${companyName}.

Quote Details:
- Quote #: ${quoteNumber}
- Amount: ${formatCurrency(quoteAmount)}
- Sent: ${quoteSentDate}
- Expires: ${expiryDate}
- Items: ${quoteItems}

Customer: ${firstName} ${lastName}
Company: ${customerCompany}
Previous conversations: ${conversationHistory}

Your job:
1. Check if they received/reviewed the quote
2. Answer questions about scope, pricing, timeline
3. Handle objections (see below)
4. Guide toward accepting

Common objections and responses:
- "Too expensive" → Break down value, offer to discuss scope adjustments
- "Need more time" → "Totally understand. What timeline are you working with?"
- "Comparing options" → "Smart! What would be most helpful to know?"
- "Need approval" → "Who else is involved? Can I provide anything to help?"

Keep messages conversational and under 160 chars for SMS.
Don't be pushy - be helpful and professional.`;

Step 4: Follow-Up Message Templates

Day 2 - Receipt Confirmation:

const day2Templates = {
  sms: `Hey {{firstName}}, just wanted to make sure you got the quote I sent over. Any questions so far?`,

  email: {
    subject: `Re: Quote #{{quoteNumber}} for {{projectName}}`,
    body: `Hi {{firstName}},

Just checking in - did you receive the quote I sent on {{quoteSentDate}}?

Quick recap:
{{quoteLineItemSummary}}
Total: {{quoteAmount}}

Let me know if you have any questions or need anything adjusted.

{{senderName}}`,
  },
};

Day 7 - Decision Status:

const day7Templates = {
  sms: `{{firstName}}, circling back on the quote. Where are you in the decision process? Anything I can help with?`,

  email: {
    subject: `Quick check-in on your {{projectType}} project`,
    body: `Hi {{firstName}},

I wanted to see where you're at with the {{projectType}} project.

Are you:
- Still reviewing?
- Need any adjustments to the quote?
- Ready to move forward?

I'm here if you need anything. Happy to jump on a quick call if that's easier.

{{senderName}}`,
  },
};

Day 14 - Social Proof:

const day14Templates = {
  sms: `{{firstName}}, thought you'd like this - we just finished a similar project for {{similarCustomer}}. They're thrilled with the results. Want to hear more?`,

  email: {
    subject: `How {{similarCustomer}} solved the same challenge`,
    body: `Hi {{firstName}},

While thinking about your project, I was reminded of similar work we did for {{similarCustomer}}.

They were facing {{similarChallenge}}, and after working with us, they achieved {{resultAchieved}}.

I think we could do something similar for you. Worth a quick chat to discuss?

{{senderName}}`,
  },
};

Step 5: Objection Handling

const quoteObjectionHandlers = {
  price: {
    detect: ["expensive", "cost", "price", "budget", "afford", "cheaper"],
    response: async (message, quoteData) => {
      // Generate value-focused response
      return await generateAIResponse(`
        Customer objected to price on a ${quoteData.amount} quote.
        Their message: "${message}"

        Respond by:
        1. Acknowledging the concern
        2. Breaking down value (not just price)
        3. Asking what their budget looks like
        4. Offering to discuss scope adjustments (NOT discounts)

        Keep it conversational, under 200 chars.
      `);
    },
  },

  timing: {
    detect: ["later", "not now", "wait", "next month", "next quarter"],
    response: async (message, quoteData) => {
      return await generateAIResponse(`
        Customer wants to delay decision on quote.
        Their message: "${message}"

        Respond by:
        1. Understanding their timeline
        2. Asking what's driving that timeline
        3. Mentioning quote expiry if relevant
        4. Offering to schedule a follow-up

        Be understanding, not pushy.
      `);
    },
  },

  comparing: {
    detect: ["other quotes", "comparing", "shopping around", "competitor"],
    response: async (message, quoteData) => {
      return await generateAIResponse(`
        Customer is comparing quotes/competitors.
        Their message: "${message}"

        Respond by:
        1. Acknowledging that's smart/normal
        2. Asking what factors are most important to them
        3. Highlighting our differentiators (quality, warranty, service)
        4. Offering to answer any comparison questions

        Be confident, not defensive.
      `);
    },
  },

  approval: {
    detect: ["check with", "boss", "spouse", "partner", "board", "approval"],
    response: async (message, quoteData) => {
      return await generateAIResponse(`
        Customer needs approval from someone else.
        Their message: "${message}"

        Respond by:
        1. Understanding who's involved
        2. Asking if we can provide anything to help (summary, comparison, ROI calc)
        3. Offering to include them in a call
        4. Setting a follow-up timeline

        Be helpful and supportive.
      `);
    },
  },
};

Step 6: Quote Expiry Handling

const handleQuoteExpiry = async (contactId, quoteData) => {
  const daysUntilExpiry = differenceInDays(quoteData.expiryDate, new Date());

  if (daysUntilExpiry === 7) {
    await sendMessage(contactId, {
      channel: "sms",
      message: `Hey ${firstName}, heads up - your quote expires in a week. Want to move forward or need more time?`,
    });
  }

  if (daysUntilExpiry === 1) {
    await sendMessage(contactId, {
      channel: "email",
      subject: `Quote expiring tomorrow`,
      body: `Hi ${firstName},

Just a heads up that your quote expires tomorrow. After that, I'd need to re-quote based on current pricing and availability.

If you're ready to move forward, let me know and I can lock this in. If timing isn't right, I can extend the quote - just let me know.

${senderName}`,
    });
  }

  if (daysUntilExpiry < 0) {
    // Quote expired - offer to re-quote
    await updateContact(contactId, { quote_status: "expired" });
    await sendMessage(contactId, {
      channel: "sms",
      message: `${firstName}, your quote expired but I'm happy to put together a new one whenever you're ready. Just let me know!`,
    });
  }
};

Step 7: Closing the Deal

When the customer indicates they want to proceed:

const handleAcceptance = async (contactId, message) => {
  // Detect acceptance signals
  const acceptanceSignals = [
    "move forward",
    "proceed",
    "accept",
    "go ahead",
    "start",
    "book",
    "schedule",
    "let's do it",
  ];

  const isAccepting = acceptanceSignals.some((signal) =>
    message.toLowerCase().includes(signal),
  );

  if (isAccepting) {
    // Update status
    await updateContact(contactId, {
      quote_status: "accepted",
      quote_sequence_active: false,
    });

    // Move opportunity forward
    await updateOpportunity(contactId, {
      stage: "Closed Won",
    });

    // Alert sales rep
    await sendSlackAlert({
      channel: "#wins",
      message: `Quote accepted by ${firstName}! Amount: ${quoteAmount}`,
    });

    // Send confirmation to customer
    await sendMessage(contactId, {
      channel: "sms",
      message: `Awesome, ${firstName}! I'll get everything set up and send over next steps shortly. Excited to work with you!`,
    });

    // Trigger onboarding workflow
    await triggerWorkflow("customer_onboarding", contactId);
  }
};

Industry-Specific Templates

Home Services (HVAC, Plumbing, Roofing)

const homeServicesTemplates = {
  day2: `Hey {{firstName}}, wanted to make sure you got the estimate for your {{projectType}}. The crew is booking up fast for {{currentMonth}} - let me know if you have questions!`,

  weatherUrgency: `{{firstName}}, with {{weatherEvent}} in the forecast, wanted to check in on your {{projectType}} estimate. Want to get it scheduled before then?`,

  socialProof: `Just finished a {{projectType}} down the street from you - homeowner was thrilled. Your neighbors are upgrading! Want to move forward on yours?`,
};

B2B Services

const b2bTemplates = {
  day2: `Hi {{firstName}}, checking that the proposal for {{projectScope}} reached you. Happy to schedule a call to walk through any questions.`,

  roiFocus: `{{firstName}}, based on what you shared about {{painPoint}}, the ROI on this should be realized within {{roiTimeline}}. Want to discuss the implementation timeline?`,

  championEnable: `{{firstName}}, I put together a one-pager summarizing the proposal that might help with internal discussions. Want me to send it over?`,
};

Metrics to Track

---

Ready to close more quotes? Get the implementation package or let us build it.