Turn WhatsApp Into a Mini Storefront With Google Sheets and AI (No Website Required)

A neighbourhood café wants to take orders without building a website. A one-person consultancy wants prospects to book a call without learning Calendly. A weekend cheesemaker wants to sell wheels of comté without paying Shopify $39 a month for a checkout page she'll use twice a week.

They all face the same question: how do I sell from WhatsApp, where my customers already are, without building a full e-commerce stack?

The standard answers are bad. Shopify, WooCommerce, and Squarespace want you to build a website first and bolt WhatsApp on later. WhatsApp Business catalogs are clunky, can't take real orders, and lock your data inside Meta. Dedicated chatbots like Wati or Zoko cost $50–$500 per month and still don't write orders into a place you can actually export.

The forgotten option: a single Google Sheet, an Apps Script web app, the official WhatsApp Business API, and a 200-line AI tool layer. Cost: under $20 a month for most small businesses. Setup time: 15–20 minutes once the pieces are wired up. Lock-in: zero — the data is in your own Drive.

This guide shows how it works, end to end, with the Apps Script code you'd actually paste into the editor. It builds on the architecture covered in our pillar post on building a WhatsApp AI CRM in Google Sheets — the storefront pattern is one specific use case of that broader CRM engine.

Why This Pattern Works for Small Businesses

The mini-storefront pattern works because it inverts the usual e-commerce assumption. Traditional online stores assume the customer arrives on a website, browses a catalog, fills a cart, and checks out. That model is built for high-volume retail with hundreds of SKUs.

Most small businesses don't look like that. A café has 12–20 menu items. A consultant offers 3 packages. A maker sells 5–8 product variants. Their customers don't browse — they ask: "What do you have today?" The right interface is conversational, not a grid of product cards.

WhatsApp is already where these conversations happen. Across most of the world it has become the default messaging channel between small businesses and their customers — Meta has publicly reported that hundreds of millions of people message a WhatsApp Business account every day, with adoption strongest in Latin America, the Middle East, Southeast Asia, and large parts of Europe. The behaviour is already there; the missing piece is the storefront layer that listens to it.

A Google Sheet is a perfect storefront database for this scale because:

1. Edits are zero-friction. Add a new product = type a new row. Change a price = retype the cell. No CMS, no admin login, no deploy.
2. The owner already knows the tool. A cafe owner who can use WhatsApp can use a Sheet. The same is not true for Shopify's product editor.
3. Reports come for free. Filter the Orders tab by date, sum a column, build a quick chart. No analytics integration needed.
4. Data stays in your Drive. Export, back up, hand to your accountant — the Sheet is yours, not Shopify's.

The trade-off: this isn't going to scale to 100 SKUs or 10,000 orders a month. For that you want a real e-commerce platform, and we discuss when to make that jump in the Limits section below.

How It All Connects

The architecture is six moving parts:

Customer phone ──▶ WhatsApp ──▶ Twilio ──▶ Apps Script ──▶ Google Sheet
                                              │              │
                                              ▼              ▼
                                          OpenAI          Products tab
                                       (function calling)  Orders tab

A customer messages your WhatsApp Business number. Twilio receives the message and posts it as a webhook to your Apps Script web app. The script looks up the customer in the Leads tab (creating a row if it's a new contact) and forwards the message to OpenAI with a system prompt and a list of available tools.

OpenAI doesn't just generate text — it decides which tool to call. "What do you sell?" triggers get_products. "Tell me about latte" triggers get_product. "I'll take two cappuccinos" triggers log_order after the AI confirms the SKU and quantity in the conversation. Each tool reads or writes to a tab in the same Sheet.

The result lands back in WhatsApp as a normal text reply, and the data — products, orders, customers, conversation history — stays in your Sheet, ready to be queried like any other spreadsheet.

The exact tool-calling pattern (how OpenAI's function-calling API maps to Apps Script handler functions) is covered in depth in our autonomous WhatsApp CRM guide. Below we focus on the storefront-specific pieces.

The Two Tabs You Need

Sheet: My Café
├── Products      ← you maintain this manually
│   SKU | Name | Description | Price | Currency | Stock | Active | Image URL
│   PRD001 | Espresso     | Single shot, freshly ground    | 3.50 | USD | 100 | TRUE
│   PRD002 | Latte        | Espresso + steamed milk        | 5.50 | USD | 100 | TRUE
│   PRD003 | Cappuccino   | Espresso + steamed milk + foam | 5.50 | USD | 100 | TRUE
│
└── Orders         ← AI writes to this
    Order ID | Customer Phone | SKU | Product Name | Quantity | Unit Price | Total | Currency | Notes | Status | Created At

That's it. The owner edits Products. The AI writes Orders. Everything else (Leads, Messages, Tools registry) is the existing CRM engine.

The Three AI Tools

The AI's behaviour comes entirely from three tools registered in your Tools sheet. Each is an Apps Script function that takes (phone, args, lead) and returns a JSON object the AI then weaves into its reply.

Tool 1 — get_products

Returns every active, in-stock product in the catalog.

function toolGetProducts(phone, args, lead) {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Products');
  if (!sheet || sheet.getLastRow() < 2) {
    return { products: [], note: 'No products configured yet.' };
  }

  const data = sheet.getDataRange().getValues();
  const products = [];
  for (let i = 1; i < data.length; i++) {
    const [sku, name, desc, price, currency, stock, active] = data[i];
    if (active !== true) continue;
    if (stock !== '' && Number(stock) <= 0) continue;
    products.push({
      sku: String(sku),
      name: String(name),
      description: String(desc || ''),
      price: Number(price),
      currency: String(currency || ''),
      in_stock: stock === '' ? null : Number(stock)
    });
  }
  return { count: products.length, products };
}

When OpenAI calls this, it receives the full menu and decides how to format it for the customer in the right language and tone — formal for a corporate buyer, casual for a regular.

Tool 2 — get_product

A single SKU lookup, used when the customer asks about one specific item.

function toolGetProduct(phone, args, lead) {
  const sku = args && args.sku ? String(args.sku).trim() : '';
  if (!sku) return { error: 'sku is required' };

  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Products');
  const data = sheet.getDataRange().getValues();
  for (let i = 1; i < data.length; i++) {
    const row = data[i];
    if (String(row[0]).toLowerCase() === sku.toLowerCase()) {
      return {
        sku: String(row[0]),
        name: String(row[1]),
        description: String(row[2] || ''),
        price: Number(row[3]),
        currency: String(row[4] || ''),
        in_stock: row[5] === '' ? null : Number(row[5]),
        active: row[6] === true
      };
    }
  }
  return { error: 'Product ' + sku + ' not found' };
}

This is what lets the AI confidently quote the right price the moment a customer says "how much is the cheesecake?" — no hallucination, the number comes from the Sheet.

Tool 3 — log_order

The action tool. Triggered only after the AI has confirmed SKU and quantity in the conversation.

function toolLogOrder(phone, args, lead) {
  const sku = args && args.sku ? String(args.sku).trim() : '';
  const qty = args && args.quantity ? Number(args.quantity) : 0;
  const notes = (args && args.notes) ? String(args.notes) : '';

  if (!sku || !qty || qty < 1) return { error: 'sku and quantity required' };

  const product = toolGetProduct(phone, { sku }, lead);
  if (product.error) return product;

  const total = product.price * qty;
  const orderId = 'ORD-' + Date.now().toString(36).toUpperCase();

  SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Orders').appendRow([
    orderId, phone, product.sku, product.name, qty,
    product.price, total, product.currency, notes,
    'pending', new Date().toISOString()
  ]);

  return {
    success: true,
    order_id: orderId,
    sku: product.sku,
    product_name: product.name,
    quantity: qty,
    total: total,
    currency: product.currency,
    status: 'pending'
  };
}

Note what this tool deliberately does not do: it does not decrement stock automatically. Inventory adjustments belong in your fulfilment workflow, not in the conversational layer — otherwise an AI that misunderstands a question can over-commit your stock. The Orders tab marks the order pending; you (or another script) update the row to fulfilled once the customer has paid and you've handed over the product.

A Real Conversation, Logged in Real Time

Once the three tools are registered and the AI's system prompt mentions them, a real WhatsApp conversation looks like this:

Customer: hi what do you sell?

AI: Hi there! Here's today's menu:
    ☕ Espresso — $3.50
    🥛 Latte — $5.50
    ☁️ Cappuccino — $5.50
    ☕ Filter Coffee — $4.50
    🧊 Iced Americano — $5.00
    🥐 Croissant — $4.00
    🍰 Cheesecake slice — $7.50

    What can I get you?

Customer: 2 lattes and 1 croissant please

AI: Got it! Just confirming:
    • 2× Latte = $11.00
    • 1× Croissant = $4.00
    Total: $15.00
    Sound good?

Customer: yes

AI: Order confirmed ✅ Your order number is ORD-MGEKP3JQ.
    We'll message you when it's ready!

Behind the scenes, two rows have appeared in the Orders tab: one for the lattes, one for the croissant. The owner sees them in real time. They prepare the order. They reply manually when it's ready. Total infrastructure: one Sheet, one Apps Script project, one WhatsApp number.

The Setup, Step by Step

If you already have Leadflow AI — WhatsApp CRM for Google Sheets installed, the storefront extension is a single file you add to your Apps Script project. It's bundled in the v2.1 release. From there:

1. Open your Sheet → Extensions → Apps Script

2. Click + → Script and name it 08_Storefront

3. Paste in the storefront code (the three tool functions above plus a setupStorefront() initialiser)

4. From the function dropdown pick setupStorefront and click Run

5. Authorise when Google asks

6. Open the Products tab and replace the demo rows with your real items

7. Open the AIConfig tab and add this line to your system prompt:

   You can sell from a product catalog. When a customer asks what you sell, call get_products. When they ask about a specific item, call get_product. When they confirm a purchase, call log_order. Always confirm SKU + quantity + total price before logging.

8. Message your WhatsApp number from any phone with "what do you sell?" — the AI should reply with your full catalog.

If you'd rather not wire it up yourself, our Custom+ tier covers this as a Quick Script ($300–$700) — you provide your menu and your WhatsApp Business credentials, we deliver the working storefront in 2–3 days.

Limits and When Not to Use This

This pattern is deliberately small. It is not the right answer for every business.

Do use it when:

• You sell 5–30 SKUs that don't change daily
• Your orders are conversational ("I'll take two of the usual"), not catalog-browsing
• You handle under ~500 messages and ~100 orders per month
• Your customer relationship is high-touch (regulars, repeat buyers, recommendations)

Don't use it when:

• You need true real-time stock across multiple sales channels — use our Google Sheets inventory management system and feed the storefront from it
• You handle thousands of SKUs or variants — you need a real PIM and an e-commerce platform
• You want full e-commerce features (multi-currency checkout, automated payment, abandoned-cart flows) — Shopify or WooCommerce earn their fees at that scale
• You sell internationally with regional tax rules — VAT/MOSS requires either Lemon Squeezy as a Merchant of Record or your own accounting setup

The mini-storefront is a beachhead, not a ceiling. Plenty of businesses run it for a year, prove the demand exists, then graduate to a proper e-commerce stack — by which point they have a year of clean order data sitting in a Sheet, ready to import.

Wrapping Up

The friction that stops small businesses from selling on WhatsApp isn't the WhatsApp part — it's the back-office part. They don't need an e-commerce platform; they need a way to capture "I'll take two" into a place they can actually export.

A Google Sheet, three Apps Script tools, and OpenAI's function-calling API close that gap. The whole thing fits in a single 200-line file, runs for under $20 a month, and leaves the data in the owner's own Drive — not Shopify's, not Meta's, not ours.

If you'd like the full code as a single drop-in file plus the demo café products as a starting catalog, Leadflow AI v2.1 ships the storefront extension included. If you want a tailored version that talks to your existing inventory system or sends Stripe payment links automatically, tell us what you need on /custom and we'll come back with a fixed-price quote within 24–48 hours.