Google Review Request Text Message (Home Services): Templates, Timing, and an Approval‑First Operator Workflow

If you’re a home services business (pest control, HVAC, plumbing, cleaning, roofing) you already know the truth:

• You can do great work and still lose the next job to the company with more reviews.
• You can “try to ask for reviews,” but once the phones ring and the schedule gets messy, the asking gets inconsistent.
• Inconsistent asking = inconsistent reviews = inconsistent local rankings.

This guide gives you two things:

1. A copy/paste library of google review request text message templates (plus one follow‑up text that doesn’t annoy people).

2. A simple, reliable system to send them the same way a great office manager would: only to the right customers, at the right time, with the right guardrails.

We’ll also show how an approval‑first operator workflow (not a brittle “set-and-forget” setup) can run this end‑to‑end—draft the message, ask you to approve, send it, and log the outcome.

The goal isn’t “more messages.” The goal is more 5‑star proof with less admin work.

Why review requests fail in home services (and what actually works)

Most review-request systems fail for boring reasons:

• Bad timing (asking before the customer feels the problem is done)
• High friction (no direct link, too many steps, “search us on Google”)
• Inconsistent execution (tech forgets, office gets busy, nobody owns it)
• Asking the wrong people (open complaint, re-service scheduled, discount/refund—don’t do it)

What actually works is just as boring:

• Pick 1–3 “review moments” and stick to them.
• Use one tap to the review screen.
• Keep it short, human, and specific.
• Add guardrails so you don’t accidentally ask an unhappy customer.

The 3 moments that convert best (timing playbook)

There isn’t one perfect time for every trade, but in home services these three moments are consistently strong. Choose one primary moment and one backup moment.

1) Right after service completion (when the win is fresh)

Best for: recurring services (pest control), quick fixes, routine maintenance.

Trigger: job marked “Completed” in your CRM / invoice system.

Rule of thumb: send within 10–60 minutes of completion.

2) After the “problem solved” confirmation

Sometimes “completed” isn’t when the customer feels relief.

Best for: urgent jobs, scary problems (rodents, wasps), anything stressful.

Trigger: customer replies “thanks,” “all good,” “you guys saved us,” or a tech notes “resolved / customer happy.”

Rule of thumb: send within 1–4 hours of that confirmation.

3) After payment (when the transaction is fully closed)

Best for: higher-ticket jobs (HVAC install, major plumbing work) where customers may want a day to breathe.

Trigger: invoice paid / balance = 0.

Rule of thumb: send within 2–24 hours of payment.

Before you copy/paste: remove friction with the right Google review link

Your text should never say “Can you Google us and leave a review?”

Instead, send a direct link that opens the review box.

Option A: Use your Google Business Profile short link (fastest)

In Google Business Profile, there’s usually a “Get more reviews” or “Share review form” option that generates a link.

Option B: Use a g.page link (nice and short)

If you have a g.page/your-business link, you can often append something like ?review=1.

Option C: Create a short URL on your domain (best for trust)

For example: https://yourcompany.com/review

That URL can redirect to your Google review link, so you can change destinations later without changing your templates.

Google review request text message templates (copy/paste library)

How to use these templates:

• Keep them under 320 characters when possible.
• Use the customer’s first name.
• Use one simple ask.
• Include your review link.
• Don’t over-explain.

Below, replace:

• {FirstName}
• {Company}
• {TechName}
• {Service}
• {ReviewLink}

Template 1: The short + friendly default

"Hi {FirstName}—thanks for choosing {Company}. If we did a great job with your {Service}, would you mind leaving a quick Google review? It really helps local businesses like ours. {ReviewLink}"

Template 2: The “technician name” version (often converts better)

"Hi {FirstName}, this is {Company}. {TechName} just wrapped up your {Service}. If everything looks good, could you leave a quick Google review? {ReviewLink}"

Template 3: Slightly more formal (great for higher-ticket jobs)

"Hi {FirstName}—thank you for trusting {Company} today. If you’re happy with the work, we’d appreciate a quick Google review here: {ReviewLink}"

Template 4: Returning customer / recurring service

"Hi {FirstName}! Appreciate you having {Company} back out for your {Service}. If you have 30 seconds, could you drop us a Google review? {ReviewLink}"

Template 5: “If anything wasn’t perfect, tell us first” (use carefully)

This can reduce negative reviews, but only if you actually respond fast.

"Hi {FirstName}—thanks again for choosing {Company}. If you were happy with the {Service}, we’d love a quick Google review: {ReviewLink}. If anything wasn’t perfect, reply here and we’ll fix it."

Template 6: For office manager sending manually (no tech name)

"Hi {FirstName}, this is {Company}. Thanks for letting us help today. Would you leave us a quick Google review? {ReviewLink}"

The follow-up text (1 reminder max)

Follow-ups work—but too many will annoy people and can trigger opt-outs.

Send 1 reminder only if there’s no review after 48–72 hours.

Follow-up template

"Hi {FirstName}—quick reminder from {Company}. If you meant to leave a Google review but got busy, here’s the link: {ReviewLink}. Thanks again."

Stop conditions:

• they leave a review
• they reply with a complaint
• they opt out

The decision tree: who gets asked (and who gets escalated)

The biggest reputation mistakes aren’t about copy—they’re about asking the wrong customer.

Here’s a simple decision tree you can implement even without fancy tools:

Ask for a review when ALL are true

• Job is marked Completed
• No open complaint / no re-service scheduled
• No refund, heavy discount, or “make-good” credit
• Customer sentiment is neutral-to-positive (or unknown)

Do NOT ask for a review if ANY are true

• Job is not fully resolved
• Customer asked for a manager call-back
• Ticket includes keywords like: “angry,” “upset,” “not happy,” “missed,” “damage,” “refund”
• Re-service or follow-up appointment is scheduled

Instead, escalate internally

If something is off, route it to the owner/manager with context:

• customer name + job id
• last messages
• tech notes
• reason for hold

A simple rules table

The Approval‑First Operator Workflow (step-by-step blueprint)

A great review system behaves like a trained employee:

• It knows when to act.
• It drafts the right message.
• It asks for approval before sending.
• It logs what happened.
• It stops when it should stop.

That’s the “operator” approach.

Inputs your operator needs

Minimum viable inputs:

• customer_first_name
• customer_mobile
• service_type (e.g., “AC tune-up”)
• job_status (completed?)
• tech_name (optional)
• review_link

Nice-to-have inputs (for safer guardrails):

• invoice_status (paid?)
• reservice_scheduled (boolean)
• refund_or_discount_flag (boolean)
• last_customer_message / sentiment
• internal_notes (tech notes)

Workflow steps

1. Trigger: job completed (or invoice paid)
2. Eligibility check: suppress asks when risk flags exist
3. Draft message: choose the best template + fill placeholders
4. Approval request: send manager/owner a preview (Approve / Edit / Skip)
5. Send SMS: only after approval
6. Log outcome: record sent, delivered, clicked (if available), review left (if trackable)
7. Follow-up: 1 reminder after 48–72 hours (optional) with stop conditions

Example workflow logic (pseudo-code)

type Job = {
  id: string
  customerFirstName: string
  customerMobile: string
  serviceType: string
  techName?: string
  status: "scheduled" | "in_progress" | "completed"
  invoicePaid?: boolean
  reserviceScheduled?: boolean
  refundOrDiscountFlag?: boolean
  complaintFlag?: boolean
  reviewLink: string
}

function eligibleForReviewAsk(job: Job) {
  if (job.status !== "completed") return false
  if (job.reserviceScheduled) return false
  if (job.refundOrDiscountFlag) return false
  if (job.complaintFlag) return false
  return true
}

function buildReviewSms(job: Job) {
  const techLine = job.techName ? `${job.techName} just wrapped up your ${job.serviceType}. ` : ""
  return `Hi ${job.customerFirstName}, this is ${jobCompanyName}. ${techLine}If everything looks good, could you leave a quick Google review? ${job.reviewLink}`
}

Example “operator-style” workflow definition (YAML)

Use this as a blueprint for whatever system you implement.

name: review_request_operator
trigger:
  event: job.completed

steps:
  - id: load_job_context
    action: fetch_job

  - id: eligibility_gate
    action: decision
    rules:
      - if: "reservice_scheduled == true"
        then: "stop_and_notify_manager"
      - if: "refund_or_discount_flag == true"
        then: "stop_and_notify_manager"
      - if: "complaint_flag == true"
        then: "stop_and_notify_manager"

  - id: draft_sms
    action: generate_message
    inputs:
      template: "tech_name_variant"
      variables:
        FirstName: "{{customer_first_name}}"
        Company: "{{company_name}}"
        TechName: "{{tech_name}}"
        Service: "{{service_type}}"
        ReviewLink: "{{review_link}}"

  - id: approval
    action: request_approval
    channel: "owner_or_manager"
    message_preview: "{{draft_sms}}"

  - id: send_sms
    action: sms.send
    to: "{{customer_mobile}}"
    body: "{{approved_sms}}"

  - id: log
    action: write_log
    fields:
      job_id: "{{job_id}}"
      status: "sent"
      sent_at: "{{now}}"

  - id: follow_up
    action: schedule
    delay: "72h"
    run:
      - action: check_review_received
      - action: sms.send
        when: "review_received == false"
        body: "Hi {{FirstName}}—quick reminder from {{Company}}. If you got busy, here’s the link: {{ReviewLink}}"

Personalization without creepiness (the “business brain” approach)

Personalization boosts conversion because it proves you’re a real company that did real work.

But there’s a line between “helpful” and “creepy.”

Safe personalization signals

• Service type (“your AC tune-up”)
• Technician name
• A simple location reference (“today in {City}”) if you already normally reference it
• A generic job note (“thanks for having us out today”)

Risky personalization signals (avoid)

• Detailed notes about someone’s home, family, schedule, or personal circumstances
• Anything that sounds like you’re “watching” them
• Mentioning internal notes or sensitive details

How an operator helps

An operator can pull context from your connected tools (CRM fields, job notes, invoice status) but still keep strict boundaries:

• Only use a whitelisted set of fields for customer-facing messages.
• Route drafts to approval first.
• Store an audit trail of what was sent and why.

What to measure (simple KPI dashboard)

You don’t need a fancy BI setup. Track these weekly:

Implementation options (from manual to operator)

Option 1: Manual sending

• Works for very small teams.
• Fails at scale.

Option 2: Basic rules in your CRM

• Better consistency.
• Usually lacks approval, context, and nuanced stop conditions.

Option 3: Approval‑first operator layer (recommended)

This is where nNode (also called Endnode) fits.

Instead of you “building automations,” you onboard an operational AI operator that:

• connects to the tools you already use (Gmail/Google Workspace, CRM, invoicing, etc.)
• builds a lightweight business brain from approved context
• drafts the review SMS at the right moment
• asks for approval before sending
• sends, logs, and follows up once (then stops)

It’s the difference between a brittle setup and a system that behaves like a dependable employee.

FAQ: Google review requests via text (quick answers)

How do I ask for a Google review via text?

Keep it short, send a direct link, and ask right after the customer feels the job is done. Use the templates above and avoid asking anyone with an open issue.

Should I offer a discount or gift for a review?

In many cases it creates compliance and trust issues (and can attract low-quality reviews). A better strategy is consistency + timing + low friction.

How many follow-ups should I send?

One reminder max, 48–72 hours later. More than that increases opt-outs and complaints.

What if a customer replies with a complaint?

Don’t push for a review. Route it to your manager/owner immediately and resolve the issue. Your workflow should suppress further asks.

Next step: turn templates into a reliable “review operator”

If you want, you can absolutely start today by copy/pasting a template and sending it manually.

But if your real goal is to get more Google reviews for your business without adding admin work, you’ll want the system to run the same way every time—with approvals and guardrails.

That’s what we’re building at nNode: an approval‑first operational AI operator for home services. One of the first bundles we’re shipping is exactly this: review requests + estimate follow-ups—the two workflows that compound into more jobs and a stronger local moat.

If you’d like to see what onboarding looks like (and what tools we can connect to in your stack), take a look at https://nnode.ai.