AI chatbot for your business website: what actually works

An AI chatbot for a business website should do three things: answer common questions accurately, qualify and route real leads, and reduce support load without annoying customers. Start with your own content (FAQs, policies, product data), wire it into your CRM and helpdesk, and measure containment and conversion from day one. Expect 30–50% support deflection and a 10–20% lift in qualified leads when it’s built properly.

What good looks like (and the numbers we actually see)

If you’re evaluating an AI chatbot, avoid vague promises and focus on measurable outcomes:

• Containment rate: percentage of conversations resolved without a human. On well‑documented sites, we see 35–60%. If it’s under 20%, the bot isn’t trained on the right content or lacks tools to act.
• First response time: should be sub‑2 seconds for the first message. Anything slower tanks engagement.
• Lead conversion: uplift of 10–20% on qualified demo requests when the bot asks two to three crisp questions and writes to your CRM.
• Support deflection: 30–50% fewer repetitive tickets (order status, shipping, returns) once connected to your systems.
• CSAT: aim for 4.3/5+ when handoff to a human is obvious and easy.

Two quick examples from recent builds:

• DTC skincare brand on Shopify (180k monthly sessions): integrated with Shopify Admin GraphQL API for order lookups, restock dates, and returns flow. 42% chat containment, 18% fewer WISMO (“where is my order?”) tickets, average model cost ~£95/month at ~12k chats.
• B2B SaaS (30k monthly sessions): bot qualifies by ICP, budget, timeline; writes to HubSpot with a clean lead source and adds transcript. 17% increase in demo bookings, 11 minutes average faster first touch. No hallucinations after we enforced retrieval‑only answers.

Off‑the‑shelf vs custom: choose the shortest path to value

There’s no single right platform. Pick based on your stack, volumes, and how specific your workflows are.

• Off‑the‑shelf live‑chat + AI: Intercom Fin, Zendesk bots, Tidio, Crisp. Good UI, built‑in inbox, quick deployment. You’ll pay a platform fee plus model usage. Best for teams that already use the platform.
• Bot builders with strong RAG: Botpress, Voiceflow, Cognigy. Faster to orchestrate content ingestion and FAQs with decent analytics. Limited when you need deep custom integrations.
• Fully custom: your front‑end widget + API + vector store + n8n/Make automations. Use OpenAI/Azure OpenAI/Anthropic for models, pgvector or Pinecone for search, and Shopify/Admin/HubSpot/Slack for actions. More upfront work but cheaper to run at scale and fully tailored to your data and processes.

Our rule of thumb:

• Under 5k chats/month and a standard tool stack? Use your existing helpdesk or chat provider’s AI add‑on.
• 5k–50k chats/month or specialised workflows (Shopify custom apps, bespoke pricing, field services scheduling)? Go custom with a lightweight stack: Postgres + pgvector, n8n, a serverless API, and your choice of model.

Your data is the product: get RAG right, or don’t launch

Most failures come from poor content pipelines, not the model. Retrieval‑augmented generation (RAG) must be deliberate:

• Sources: sitemap crawl (docs, FAQs, policies), PDFs (manuals, T&Cs), CMS pages (WordPress, Shopify Online Store 2.0), helpdesk articles (Zendesk/Freshdesk), internal docs (Notion/Confluence). Keep a list and update cadence.
• Chunking: 500–800 tokens per chunk is a decent start; keep headings and lists intact. Larger chunks help with context; smaller chunks reduce drift.
• Embeddings: choose a single, cost‑effective embedding model and stick with it for consistency. Store embeddings in pgvector or Pinecone with metadata (URL, last updated, locale).
• Citations: show the source link in every answer where retrieval is used. It builds trust and helps your team spot stale content.
• Retrieval rules: if no relevant chunks clear a similarity threshold (e.g., 0.82 cosine), the bot should say it doesn’t know and offer escalation.
• Freshness: re‑index changed pages nightly. For product catalogues, watch webhooks (Shopify product/update) and refresh records within minutes.

A minimal RAG pipeline we use a lot:

• Crawler (Apify) or a site map pull + HTML to Markdown (Readability) → chunker → embeddings (server‑side) → Postgres/pgvector.
• On query: retrieve top‑k (4–8), re‑rank (Cohere or built‑in) → build the context window with strict system instructions → generate with a mid‑tier model.
• Log: prompt, retrieved doc IDs, score, answer, token counts, and user satisfaction.

Integrations and workflows: where the ROI appears

A chatbot that can only “chat” is a novelty. Wire it into the systems that hold answers or take actions:

• Ecommerce (Shopify Admin API, REST/GraphQL):
  • Check order status by email + postcode, fetch shipping updates, and create return requests.
  • Read stock, variants, and metafields; suggest alternatives when OOS; create draft orders.
  • Example: “Where is my order?” → bot calls n8n → Shopify order lookup → returns last fulfilment event → posts ETA and a one‑click link to carrier.
• CRM (HubSpot, Pipedrive, Salesforce):
  • Create/update contacts, add conversation transcript, set lifecycle stage, and trigger a workflow for SDR follow‑up.
  • Qualify with three questions max (role, problem, timeframe); gate calendar links until ICP criteria are met.
• Support (Zendesk, Gorgias, Freshdesk):
  • Deflect with precise KB answers, then create a ticket with the chat log and selected tags if the bot can’t resolve.
  • Auto‑tag topics (returns, billing, bugs) for weekly reporting.
• Scheduling (Calendly, Google Calendar, HubSpot Meetings):
  • Offer two slots; if accepted, create the event and email the summary with the chat transcript.
• Back‑office (Slack, Notion, Airtable):
  • Escalate to a #support‑triage channel with a deep link back to the visitor session.

Orchestrate actions with n8n or Make: you control rate limits, retries, and error paths. Keep the LLM out of business logic; pass it clean, structured data and render final messages in your app or widget.

UX that converts: the small choices matter

• Placement: a bottom‑right widget is standard, but make it silent by default. Use a subtle nudge (e.g., “Got a question about delivery times?”) after 10–15 seconds on PDPs or pricing pages.
• Clear modes: support vs sales. Start with one mode per page type using URL rules and pass a system prompt appropriate to the intent.
• Fast first reply: pre‑render a greeting instantly. Stream the model’s reply token‑by‑token so it feels responsive even if the backend is working.
• Form fallback: if a question needs an order number, show a two‑field form. Don’t ask for an email unless it’s necessary for the next step.
• Guardrails in UI: buttons for common intents (Track order, Returns policy, Book demo) outperform free‑text for first touch.
• Human handoff: visible “Talk to a person” button with SLA expectations (“usually replies in 10 minutes during office hours”). Leave a transcript behind.
• Multi‑language: detect language (CLD3) and auto‑reply in the same; only translate your fixed copy; keep sources language‑matched to avoid messy answers.

We often start with Tidio or Crisp widgets for speed, then swap to a custom React widget if we need fine control over state, streaming, and privacy banners.

Safety, quality, and compliance: non‑negotiable for UK/EU sites

• GDPR and DPA: minimise personal data. Don’t log full card numbers, sensitive health info, or anything you don’t need. Offer a data deletion request path.
• Data residency: if you must keep data in the UK/EU, pick hosting accordingly (e.g., EU region Postgres, model endpoints with EU options via Azure OpenAI).
• PII redaction: run a lightweight PII scrub before logging (emails, phone numbers, postcodes) using regex + entity detection.
• Allowed actions only: maintain an explicit allow‑list of API operations. The LLM should never decide what it’s allowed to do; your middleware enforces it.
• Moderation: apply model or external moderation for abuse. Auto‑block repeated spam/IPs.
• Hallucination control: retrieval‑first prompting with “don’t guess” instructions; if confidence is low, ask a clarifying question or escalate.
• Auditability: store prompt, retrieved doc IDs, and answer for 30–90 days max. That’s enough for QA without building a permanent transcript warehouse.

Measuring and improving: dashboards that drive decisions

Track KPIs by page type, country, and traffic source:

• Answer rate and containment rate.
• Handoff rate by topic and the average time to resolution.
• Conversion from chat to lead/demo/order.
• CSAT (one‑tap thumbs up/down with an optional comment, not a ten‑question survey).
• Cost per resolved conversation (model + platform + operator time).

Tactics that move the needle fast:

• Close the loop on “I don’t know” events: add the missing doc or write a 120‑word FAQ; re‑index; re‑test.
• A/B prompts: short, assertive system prompts usually win (“Only answer from sources. If unknown, say so and offer handoff.”). Measure containment swing.
• Train on negative cases: create a test set of 50–100 tricky questions (pricing edge cases, warranty quirks, multi‑item returns). Run nightly evals and track accuracy.
• Seasonal content: pre‑load Black Friday shipping cut‑offs or bank holiday hours; add a top‑of‑chat hint.

We build small internal tooling to replay real chats against new prompts/models before rolling to production. It pays for itself the first time a change would tank CSAT.

Costs and a 60‑day rollout plan

Rough budget ranges we see for SMEs:

• Platform/licensing: £0–£600/month (depending on whether you use your existing helpdesk/chat provider).
• Model usage: £50–£300/month for 10–20k chats on mid‑tier models, higher if you stream long answers or process attachments.
• Infrastructure: £50–£200/month (Postgres, vector DB, serverless functions, log storage).
• Build/maintenance: one‑off project, then 4–12 hours/month for content updates and QA.

A pragmatic 60‑day plan:

• Week 1–2: goals, pages, and KPIs; pick platform; extract existing FAQs/policies; define integrations and handoff paths.
• Week 3–4: RAG indexing (site + helpdesk + PDFs); wire CRM/helpdesk; implement order lookup if ecommerce; decide on prompts, thresholds, and guardrails.
• Week 5: soft launch on 10–20% of traffic to high‑intent pages; set up dashboards; daily QA on low‑confidence answers.
• Week 6–7: expand coverage; add proactive nudges on PDP/pricing; tune prompts and retrieval thresholds; add two more actions (e.g., returns, demo booking).
• Week 8: formal review; lock KPIs; document runbook; schedule monthly content refresh and quarterly model re‑eval.

If you’d like us to shape this around your stack, here’s our service page: AI Chatbots. Or skip to a conversation and book a free discovery call.

Implementation details we see again and again

• Prompts: keep system prompts under 300–400 tokens, be explicit (“If context is empty or irrelevant, say you don’t know. Never invent policy or pricing.”). Provide a two‑line brand voice guide.
• Context: cap at 6–10k tokens. More isn’t always better; retrieval quality beats bloat.
• Attachments: extract text from PDFs/Docs server‑side (Tika, PDF.js), then summarise for the model; don’t dump full documents into the prompt.
• Observability: log token counts and latency per step. If retrieval takes >200ms, fix indexing or move the vector DB closer to your API.
• Rate limits: Shopify GraphQL allows bursts but will throttle; implement retries with back‑off in n8n and cache recent lookups for 60–180 seconds.
• Browser privacy: only collect what you need (page URL, referrer, UTM, country). Respect Do Not Track.

When you shouldn’t use an AI chatbot

• Your knowledge isn’t written down. If returns, warranties, or pricing live in someone’s head, write them first.
• You need guaranteed legal answers. Route to a human or show signed‑off policy verbatim with zero generation.
• You expect it to fix a broken support process. It will amplify whatever you already have.

Working example setups (steal these)

• Shopify store with order tracking and returns:
  • Widget (Crisp) → API (FastAPI) → RAG (pgvector) → LLM (mid‑tier) → Actions via n8n (Shopify Admin GraphQL for orders, returns app webhook) → Zendesk ticket if unresolved.
• B2B SaaS with lead qualification:
  • Widget (Intercom) → Fin or custom LLM → HubSpot contact + deal creation, transcript attached → Calendly slot booking → Slack #sales‑alerts with summary.
• Content‑heavy site (publishing/education):
  • Widget (custom React) → RAG on 2–5k articles → strict citation rules → paywall‑aware responses → SerpAPI only for sanctioned live lookups (e.g., exchange rates), never general web search.

If you want this set up without the guesswork, see AI Chatbots, or just book a free discovery call with our team in Bournemouth.

FAQ

Will an AI chatbot replace my support team?

No. It should handle repetitive queries and data lookups so your team can focus on exceptions and higher‑value cases. Expect 30–50% ticket deflection, not 100%.

How do we stop hallucinations?

Use retrieval‑first prompts, strict source citation, and a confidence threshold that forces a handoff when context is weak. Don’t let the model guess policies or pricing.

What model should we use?

Pick a mid‑tier, cost‑effective model for most answers and reserve larger models for edge cases. Evaluate on your own 50–100 question test set before committing.

How long does it take to launch?

A focused pilot goes live in 3–4 weeks if your content is ready and integrations are straightforward. Full rollout with measurement and tuning takes around 6–8 weeks.