TLDR: https://github.com/xarg/pghoard-k8s

‍

This is a small tutorial on how to do incremental backups using pghoard for your PostgreSQL (I assume you’re running everything in Kubernetes). This is intended to help people to get started faster and not waste time finding the right dependencies, etc..

‍

pghoard is a PostgreSQL backup daemon that incrementally backups your files on a object storage (S3, Google Cloud Storage, etc..).
For this tutorial what we’re trying to achieve is to upload our PostgreSQL to S3.

‍

First, let’s create our docker image (we’re using the alpine:3.4 image cause it’s small):

FROM alpine:3.4

ENV REPLICA_USER "replica"
ENV REPLICA_PASSWORD "replica"

RUN apk add --no-cache \
   bash \
   build-base \        
   python3 \
   python3-dev \
   ca-certificates \
   postgresql \
   postgresql-dev \
   libffi-dev \
   snappy-dev
RUN python3 -m ensurepip && \
   rm -r /usr/lib/python*/ensurepip && \
   pip3 install --upgrade pip setuptools && \
   rm -r /root/.cache && \
   pip3 install boto pghoard


COPY pghoard.json /pghoard.json.template
COPY pghoard.sh /

CMD /pghoard.sh

‍

‍

REPLICA_USER and REPLICA_PASSWORD env vars will be replaced later in your Kubernetes conf by whatever your config is in production, I use those values to test locally using docker-compose.

‍

The config pghoard.json which tells where to get your data from and where to upload it and how:

‍

{
   "backup_location": "/data",
   "backup_sites": {
       "default": {
           "active_backup_mode": "pg_receivexlog",
           "basebackup_count": 2,
           "basebackup_interval_hours": 24,
           "nodes": [
               {
                   "host": "YOUR-PG-HOST",
                   "port": 5432,
                   "user": "replica",
                   "password": "replica",
                   "application_name": "pghoard"
               }
           ],
           "object_storage": {
               "aws_access_key_id": "REPLACE",
               "aws_secret_access_key": "REPLACE",
               "bucket_name": "REPLACE",
               "region": "us-east-1",
               "storage_type": "s3"
           },
           "pg_bin_directory": "/usr/bin"
       }
   },
   "http_address": "127.0.0.1",
   "http_port": 16000,
   "log_level": "INFO",
   "syslog": false,
   "syslog_address": "/dev/log",
   "syslog_facility": "local2"
}

‍

Obviously replace the values above with your own. And read pghoard docs for more config explanation.

‍

Note: Make sure you have enough space in your /data; use a Google Persistent Volume if you DB is very big.

‍

Launch script which does 2 things:

1. Replaces our ENV variables with the right username and password for our replication (make sure you have enough connections for your replica user)
2. Launches the pghoard daemon.

‍

‍

#!/usr/bin/env bash

set -e

if [ -n "$TESTING" ]; then
   echo "Not running backup when testing"
   exit 0
fi

cat /pghoard.json.template | sed "s/\"password\": \"replica\"/\"password\": \"${REPLICA_PASSWORD}\"/" | sed "s/\"user\": \"replica\"/\"password\": \"${REPLICA_USER}\"/" > /pghoard.json
pghoard --config /pghoard.json

‍

Once you build and upload your image to gcr.io you’ll need a replication controller to start your pghoard daemon pod:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: pghoard
spec:
 replicas: 1
 selector:
   app: pghoard
 template:
   metadata:
     labels:
       app: pghoard
   spec:
       containers:
       - name: pghoard
         env:
           - name: REPLICA_USER
             value: "replicant"
           - name: REPLICA_PASSWORD
             value: "The tortoise lays on its back, its belly baking in the hot sun, beating its legs trying to turn itself over. But it can't. Not with out your help. But you're not helping."
         image: gcr.io/your-project/pghoard:latest

‍

The reason I use a replication controller is because I want the pod to restart if it fails, if a simple pod is used it will stay dead and you’ll not have backups.

‍

Future to do:

• Monitoring (are you backups actually done? if not, do you receive a notification?)
• Stats collection.
• Encryption of backups locally and then uploaded to the cloud (this is supported by pghoard).

Hope it helps, stay safe and sleep well at night.

‍

Again, repo with the above: https://github.com/xarg/pghoard-k8s

At Gorgias we recently switched our flask & celery apps from Google Cloud VMs provisioned with Fabric to using docker with kubernetes (k8s). This is a post about our experience doing this.

‍

Note: I'm assuming that you're somewhat familiar with Docker.

‍

Docker structure

The killer feature of Docker for us is that it allows us to make layered binary images of our app. What this means is that you can start with a minimal base image, then make a python image on top of that, then an app image on top of the python one, etc..

‍

Here's the hierarchy of our docker images:

• gorgias/base - we're using phusion/baseimage as a starting base image.
• gorgias/pgbouncer
• gorgias/rabbitmq
• gorgias/nginx - extends gorgias/base and installs NGINX
• gorgias/python - Installs pip, python3.5 - yes, using it in production.
• gorgias/app - This installs all the system dependencies: libpq, libxml, etc.. and then does pip install -r requirements.txt
• gorgias/web - this sets up uWSGI and runs our flask app
• gorgias/worker - Celery worker

‍

Piece of advice: If you used to run your app using supervisord before I would advise to avoid the temptation to do the same with docker, just let your container crash and let k8s handle it.

‍

Now we can run the above images using: docker-compose, docker-swarm, k8s, Mesos, etc...

‍

We chose Kubernetes too

There is an excellent post about the differences between container deployments which also settles for k8s.

‍

I'll also just assume that you already did your homework and you plan to use k8s. But just to put more data out there:

‍

Main reason: We are using Google Cloud already and it provides a ready to use Kubernetes cluster on their cloud.

‍

This is huge as we don't have to manage the k8s cluster and can focus on deploying our apps to production instead.

‍

Let's begin by making a list of what we need to run our app in production:

• Database (Postgres)
• Message queue (RabbitMQ)
• App servers (uWSGI running Flask)
• Web servers (NGINX proxies uWSGI and serves static files)
• Workers (celery)

‍

Why Kubernetes again?

We ran the above in a normal VM environment, why would we need k8s? To understand this, let's dig a bit into what k8s offers:

• A pod is a group of containers (docker, rtk, lxc...) that runs on a Node. It's a group because sometimes you want to run a few containers next to each other. For example we are running uWSGI and NGINX on the same pod (on the same VM and they share the same ip, ports, etc..).
• A Node is a machine (VM or metal) that runs a k8s daemon (minion) that runs the Pods.
• The nodes are managed by the k8s master (which in our case is managed by the container engine from Google).
• Replication Controller or for short rc tells k8s how many pods of a certain type to run. Note that you don't tell k8s where to run them, it's master's job to schedule them. They are also used to do rolling updates, and autoscaling. Pure awesome.
• Services take the exposed ports of your Pods and publishes them (usually to the Public). Now what's cool about a service that it can load-balance the connections to your pods, so you don't need to manage your HAProxy or NGINX. It uses labels to figure out what pods to include in it's pool.
• Labels: The CSS selectors of k8s - use them everywhere!
• ‍

There are more concepts like volumes, claims, secrets, but let's not worry about them for now.

‍

Postgres

We're using Postgres as our main storage and we are not running it using Kubernetes.

‍

Now we are running postgres in k8s (1 hot standby + pghoard), you can ignore the rest of this paragaph.

The reason here is that we wanted to run Postgres using provisioned SSD + high memory instances. We could have created a cluster just for postgres with these types of machines, but it seemed like an overkill.

The philosophy of k8s is that you should design your cluster with the thought that pods/nodes of your cluster are just gonna die randomly. I haven't figured our how to setup Postgres with this constraint in mind. So we're just running it replicated with a hot-standby and doing backups with wall-e for now. If you want to try it with k8s there is a guide here. And make sure you tell us about it.

‍

RabbitMQ

RabbitMQ (used as message broker for Celery) is running on k8s as it's easier (than Postgres) to make a cluster. Not gonna dive into the details. It's using a replication controller to run 3 pods containing rabbitmq instances. This guide helped: https://www.rabbitmq.com/clustering.html

‍

uWSGI & NGINX

As I mentioned before, we're using a replication controller to run 3 pods, each containing uWSGI & NGINX containers duo: gorgias/web & gorgias/nginx. Here's our replication controller web-rc.yaml config:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: web
spec:
 replicas: 3 # how many copies of the template below we need to run
 selector:
   app: web
 template:
   metadata:
     labels:
       app: web
   spec:
     containers:
     - name: web
       image: gcr.io/your-project/web:latest # the image that you pushed to Google Container Registry using gcloud docker push
       ports: # these are the exposed ports of your Pods that are later used by the k8s Service
         - containerPort: 3033
           name: "uwsgi"
         - containerPort: 9099
           name: "stats"
     - name: nginx
       image: gcr.io/your-project/nginx:latest
       ports:
         - containerPort: 8000
           name: "http"
         - containerPort: 4430
           name: "https"
       volumeMounts: # this holds our SSL keys to be used with nginx. I haven't found a way to use the http load balancer of google with k8s.  
         - name: "secrets"
           mountPath: "/path/to/secrets"
           readOnly: true
     volumes:
       - name: "secrets"
         secret:
           secretName: "ssl-secret"
And now the web-service.yaml:apiVersion: v1
kind: Service
metadata:
 name: web
spec:
 ports:
 - port: 80
   targetPort: 8000
   name: "http"
   protocol: TCP
 - port: 443
   targetPort: 4430
   name: "https"
   protocol: TCP
 selector:
   app: web
 type: LoadBalancer

‍

That type: LoadBalancer at the end is super important because it tells k8s to request a public IP and route the network to the Pods with the selector=app:web.
If you're doing a rolling-update or just restarting your pods, you don't have to change the service. It will look for pods matching those labels.

‍

Celery

Also a replication controller that runs 4 pods containing a single container: gorgias/worker, but doesn't need a service as it only consumes stuff. Here's our worker-rc.yaml:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: worker
spec:
 replicas: 2
 selector:
   app: worker
 template:
   metadata:
     labels:
       app: worker
   spec:
     containers:
     - name: worker
       image: gcr.io/your-project/worker:latest

‍

‍

Some tips

• Installing some python deps take a long time, for stuff like numpy, scipy, etc.. try to install them in your namespace/app container using pip and then do another pip install in the container that extends it, ex: namespace/web, this way you don't have to rebuild all the deps every time you update one package or just update your app.
• Spend some time playing with gcloud and kubectl. This will be the fastest way to learn of google cloud and k8s.
• Base image choice is important. I tried phusion/baseimage and ubuntu/core. Settled for phusion/baseimage because it seems to handle the init part better than ubuntu core. They still feel too heavy. phusion/baseimage is 188MB.

‍

‍

Conclusion

With Kubernetes, docker finally started to make sense to me. It's great because it provides great tools out of the box for doing web app deployment. Replication controllers, Services (with LoadBalancer included), Persistent Volumes, internal DNS. It should have all you need to make a resilient web app fast.

At Gorgias we're building a next generation helpdesk that allows responding 2x faster to common customer requests and having a fast and reliable infrastructure is crucial to achieve our goals.

If you're interested in working with this kind of stuff (especially to improve it): we're hiring!

We've released a new version of the Chrome Extension, with sharing features and a new navigation bar. We hope you'll love it!

‍

Share templates inside the extension

Before, the only way to share templates with your teammates was to login on Gorgias.io.

If you're on the startup plan, when you create a template, you can choose who has access to it: either only you, specific people, or your entire team.

‍

‍

The account management section is now available in the extension, under settings.

‍

New navigation

Tags are now available on the left. It's easier to manage hundreds of templates with them.
You can also navigate through your private & shared templates. Shared templates include templates shared with specific people or with everyone.

‍

‍

We hope you'll enjoy this new version of our Chrome Extension. As usual, your feedback & questions are welcome!

Today, we’re thrilled to announce that we’ve raised a $1.5 million Seed round led by Charles River Ventures and Amplify Partners, to help build our new helpdesk.

‍

We’re incredibly grateful to early users, customers, mentors we’ve met both at and Techstars.

‍

We started the journey with Alex at the beginning of 2015 with our Chrome extension, which helps write email faster using templates. We’ve been pleased all along with customers telling us about how helpful it was, especially for customer support.

‍

While building the extension, we’ve realized that a big inefficiency in support lies in the lack of integration between the helpdesk, the payment system, CRM and other tools support is using. As a result, agents need to do a lot of repetitive work to respond to customer requests, especially when the company is big.

‍

That’s why we’ve decided to build a new kind of helpdesk to enable customer support agents to respond 2x faster to customers. You can find out more and sign up for our private beta here.

‍

When a company has a lot of customers, support becomes repetitive. We want to provide support teams with tools to automate the way they treat simple repetitive requests. This way, they have more time for complex customer issues.

‍

We'll now focus on this helpdesk and on growing the team, oh, and if you'd like to join, we're hiring! We're super excited about this new helpdesk product. If you’re using the extension, don’t worry.

‍

Romain & Alex

We've been busy, but not deaf!

Last few months we got lots of feedback about our extension and found to our delight that most people are satisfied, but still a few recurrent issues came up:

• The HTML/WYSIWYG editor sucks.
• No support for Outlook.com.

‍

We listened and now we're presenting:

• A brand new editor
• Support for outlook.com
• More on the Rich-Text editor

‍

WYSIWYG editors for the web are notoriously buggy and are just difficult to develop.

‍

I have yet to see one that is bug free. There are few venerable editors that do a good job like TinyMCE, FKEditor or CKEditor.. but they are big and all have edge cases that break the intended formatting and add a lot of garbage html.

‍

There are newer good quality editors in town such as Redactor. The one that got my attention and finally landed in Gorgias is this wonderful editor called which is super lightweight, uses modern content-editable (no i-frames) and 'just works' most of the time. That's not to say it's perfect, but it's good enough and I'm satisfied with it's direction in terms of development.

‍

Enjoy it and as always send us bug-reports or feedback on: support@gorgias.com

TL;DR:

• Your CX team drives revenue: Build trust, remove friction, and influence buying decisions across the customer journey
• Optimize existing processes: Automate tasks, address concerns proactively, and create efficient handoffs
• Spot risk early: Use tagging and sentiment detection to re-engage customers before they churn
• Protect VIPs: Prioritize loyal customers, create moments of delight, turn supporters into advocates

Rising tariffs. Shipping delays. Unpredictable price hikes. For ecommerce, it's an understatement to say the pressure is rising. If you're on the CX team, you're already facing the fire head-on — all the customer frustration, confusion, and hesitation.

CX teams are on the frontlines of support and sales. You're shaping customer trust, buying decisions, and brand loyalty. 

From pre-sales conversations to loyalty programs, it’s time to rethink the customer journey, so you can turn every interaction into an opportunity to grow your revenue.

Reframe CX’s role across the customer journey

Customer service isn’t just about reacting to problems. It can be a proactive and strategic function that helps you stabilize and even grow your revenue.

Think about it this way: you have the power to turn everyday customer moments into wins.

At every stage of the customer journey, you can turn:

1. Purchase hesitation -> confidence to buy (pre-sales)
2. Concern → relief (post-purchase)
3. Disinterest -> re-engagement (loyalty)
4. Returning customers → brand advocates (advocacy)

This isn’t about being pushy for sales. It's about anticipating needs and putting systems in place that protect customer relationships and revenue.

As you update your CX workflow, keep these two questions in mind:

1. How can I positively influence revenue?
2. How can I reduce the risk of losing it?

1. Resolve pre-sales hesitation with education

Most pre-sales hesitation is rooted in uncertainty: What’s the return policy? How much is shipping? Will this fit? Will it arrive in time? 

Reduce customer effort and build confidence with automation as your CX team’s first line of defense. Anything else more complicated, your agents can take care of.

Automate repetitive questions

Start by setting up automated answers for the questions your team responds to every day, especially the ones that delay conversions:

• Where is my order?
• Do you ship internationally?
• How much is shipping?
• Do you accept returns?
• Are your prices affected by tariffs?

There are a few ways to automate these questions in Gorgias: 

• Flows: Automated conversations designed to resolve common inquiries without agent intervention
• AI Agent: Conversational AI that answers customer questions in chat and email, trained on your internal documents and brand voice
• Help Center: A self-serve, customer-facing knowledge base of help articles, FAQs, guides, and product resources

Read more: How to optimize your help center for AI Agent

Proactively guide shoppers

Be the compass for the wandering window shoppers and browsers. They might not know exactly what to get, but with the right nudge, you can guide them toward the right product and a fuller cart.

Try these chat prompts:

• Don’t know what size to get? Check out our sizing guide to get your perfect fit!
• Need help choosing the right carry-on? Here’s a quick comparison of our top sellers.
• We offer free shipping for orders over $60! 
• What’s your skin type — dry, oily, or combination?

Offer discounts based on shopper intent

Sometimes, a discount is all a customer needs to take their order to checkout. Instead of storewide promo codes, use AI to offer tailored discounts to shoppers who show strong intent to buy. This can help reduce abandoned carts and leave customers with a great impression of your brand.

Here are some of the best times to offer a discount:

• A first-time shopper is hesitant because of the price
• A shopper adds an item to their cart, then asks about shipping or return policies
• A shopper asks if they should wait for a sale

Recommend products in real time

If shoppers can’t quickly find what they’re looking for, they’ll leave. Real-time product recommendations help resolve indecision and increase average order value.

Examples of when real-time suggestions drive conversions:

• A shopper asks for jeans in medium — AI suggests bestsellers in their size
• A returning customer mentions loving a nude-colored top — AI recommends similar or matching items
• A product is out of stock — AI suggests alternatives based on color or style

Hand off high-intent shoppers to live agents

High-intent questions are usually specific and goal-oriented — things like:

• What size should I get?
• How soon can this ship?
• Is this item still in stock?

When customers ask questions that directly impact their ability to purchase, it’s a strong buying signal. If they don’t get a fast response, they’ll probably abandon their cart.

So, how do you encourage shoppers to keep shopping?

Activate chat on your website and equip it with automated features, such as Flows, and/or conversational AI, like AI Agent. 

No matter what setup you choose, always have a protocol ready to hand off to a human agent when needed.

In Gorgias, you can set up Rules or use AI Agent handover rules to automatically route conversations based on specific keywords, topics, or customer behavior.

2. Alleviate post-purchase concerns

After buying, customers may want to change their order or just need reassurance that everything is on its way. 

If customers feel ignored during this critical window, you risk losing their business.

The easy fix? Eliminate friction, reassure customers, and make it easy for them to stay excited about their purchase.

Automate order status updates

Customers expect full visibility into their orders. Give them full access to this information, and you'll receive fewer WISMO requests.

Integrate your helpdesk with your 3PL or shipping provider to automatically send real-time updates on order status. If customers have an account portal, give them a tracking link.

Pro Tip: If delays are expected, automate messages to let customers know ahead of time. Being proactive keeps customers informed and reduces the need for reactive support.

Turn negative experiences into retention moments

When something goes wrong, like a delay, a lost package, or unexpected fees, it's how you respond that matters most.

Empower your CX team to act quickly. For example:

• Offer store credit, loyalty points, or free shipping perks to impacted customers
• Prioritize VIP or first-time buyers for fast-tracked resolutions
• Escalate critical post-purchase issues to senior agents

You can also use sentiment detection to flag frustrated customers early. Gorgias has built-in customer sentiment detection that automatically identifies tones like urgent, negative, positive, or even threatening language. You can create Rules that tag these conversations and route them to the right agent for faster handling.

Read more: Customer sentiments

3. Re-engage at-risk customers and reduce churn

Just because a customer is at risk doesn’t mean you’ve lost them. Identifying and re-engaging at-risk customers is one of the highest-impact things you can do to protect revenue. 

Spot risk early

Pay attention to repeat patterns that signal dissatisfaction. Common early indicators include:

• Multiple shipping complaints
• Frequent refund or return requests
• Negative or urgent sentiment in support tickets
• Long periods of customer inactivity after purchase

Use sentiment detection and Ticket Fields (ticket properties) to tag these signals automatically. With this data identified, you’ll start to spot patterns that can help you address issues, giving customers a reason to stay. 

Build recovery flows

Once you’ve identified your at-risk customers, use win-back strategies, like:

• Offering discount codes, loyalty perks, or free returns
• Sending personalized emails or messages acknowledging the issue and offering solutions
• Prioritizing conversations for your most experienced agents or account managers

When handled thoughtfully, a churn-risk customer can become one of your strongest advocates because you showed up when it mattered most.

4. Build loyalty by surprising your best customers

Don’t forget, there are already customers who love you! These loyal customers don’t just come back to buy again — they bring friends, amplify your brand, and give your business stability when you need it most.

Identify and prioritize VIPs

Use customer data to identify customers who purchase frequently, spend more, or have referred others. Tag them as VIPs in your helpdesk so that their requests are prioritized.

For example, in Gorgias, you can use Customer Fields (customer labels and properties) to group your customers under:

• VIP
• Repeat purchaser
• High lifetime value
• Promoter

When you know who your top customers are, you can offer more personalized service and make sure every interaction strengthens their connection to your brand.

Create brand advocates through small gestures

You don’t need to offer huge discounts to let customers know you appreciate them. Small, thoughtful gestures often make the biggest impact:

• Send handwritten thank-you notes with their orders
• Offer a free gift, upgrade, or loyalty perk after a milestone purchase
• Include a referral code they can share with friends
• Feature loyal customers on your social media channels (with their permission)

If you’re using macros and automations, you can even trigger some of these surprise-and-delight actions automatically, making it easier to scale while keeping the personal touch.

Make revenue your outcome at any time

We know how overwhelming uncertain times can be. It’s easy to think you need to reinvent your entire strategy just to keep up. 

But the truth is, you already have what you need. You have a team that knows your customers. You have conversations happening every day that can protect, nurture, and even grow your business.

By grounding yourself in what’s already working and creating proactive systems, you can turn uncertainty into strong and steady growth.

{{lead-magnet-1}}

TL;DR:

• Clear policies reduce tickets. When customers can’t find return windows or shipping timelines, they turn to your support team — often unnecessarily.
• Each vertical has different CX needs. A fashion shopper wants fit info. An electronics buyer needs setup help. Tailor your policies to match.
• Proactive placement matters. Don’t bury policies in the footer — surface them in product pages, chat, emails, and account portals where customers actually look.
• Policy + AI = self-service support. Gorgias’s AI Agent can guide shoppers to answers instantly, reducing WISMO and freeing up your team for high-value work.

For many ecommerce teams, store policies are an afterthought, tucked away in the footer or buried deep in the FAQ. But they shouldn’t be.

Great customer experience (CX) starts before a customer reaches out. And with 55% of shoppers preferring self-service support, your store policies are often their first stop for answers.

In this guide, we break down the must-have policies for five key ecommerce verticals, based on real Gorgias ticket data. From shipping delays to subscription changes, you’ll learn how to prevent tickets before they happen.

{{lead-magnet-1}}

Why store policies are a CX power move

If you’re constantly fielding questions about returns, shipping times, or order changes, it’s a policy opportunity.

Well-crafted store policies are one of your CX team's most effective tools for setting expectations, building trust, and preventing support issues before they happen. When done right, they turn common friction points into effortless experiences.

Common blind spots that lead to tickets

When policies are vague or hard to find, customers turn to your inbox, driving up ticket volume and slowing down your support team.

Here are the most common blind spots we see:

• Unclear or missing return windows lead to questions like, “Can I still return this?”
• No defined process for exchanges or edits confuses customers who need to fix an order.
• Subscription rules hidden in fine print frustrate loyal customers trying to pause, skip, or cancel.
• Shipping timelines that shift without explanation cause “Where’s my order?” messages that could’ve been avoided.

When policies aren’t clear or easy to find, customers turn to your inbox. And that means more tickets, wait times, and pressure on your team.

Proactive policies = fewer tickets, happier customers

Based on real data from Gorgias, these are the top 10 tickets customers send across channels like chat, contact forms, and email:

1. Order damaged
2. No reply tickets
3. Shipping policy
4. Shipping change
5. Order change
6. Product question
7. Return status
8. Thank you tickets
9. Discount request
10. Shipping status

What do most of these have in common? You can address them with clear, accessible policies. 

15 store policies you need, organized by industry

Customer expectations aren’t one-size-fits-all, and your store policies shouldn’t be either.

What shoppers expect from a fashion brand is very different from what they need from a wellness company or electronics provider. 

We’ve broken down the top policy must-haves by vertical, using real-world examples from Gorgias customers and ticket data.

Use these examples as your plug-and-play guide to write better policies, reduce ticket volume, and create smoother support experiences — no matter what you sell.

1. Apparel and fashion

When it comes to fashion, uncertainty drives tickets. “Will this fit?” “Can I return it?” “Where’s my order?” The most successful fashion brands like Princess Polly cut down on support volume by making these answers easy to find before customers ever reach out.

Key policies to prioritize

• Returns and exchanges: Be clear on timeframes, conditions, and the process. Bonus points for adding visuals or quick links to return portals.
• Size guide and fit: To minimize confusion, include details on model sizing, garment measurements, and fit notes.
• Order changes: Let customers know how to update their order before it ships.
• Shipping timelines: Set expectations around processing and delivery windows (especially during peak seasons).

Where to share store policies

• Link return and shipping policies on product detail pages (PDPs).
• Trigger chat campaigns with the sizing guide when shoppers linger on product pages.
• Add return instructions in post-purchase emails to cut “How do I return this?” tickets.

2. Consumer goods

Consumer goods customers often want to know two things right away: “What’s it made of?” and “When will it get here?” These questions can quickly pile up in your inbox if your policies aren’t front and center.

Trove Brands, home to household favorites like BlenderBottle and Owala, solves this by proactively answering product and shipping questions across their site and emails.

Key policies to prioritize

• Shipping: Share estimated delivery times, carrier information, and instructions on how customers can track their orders.
• Product specs and materials: List dimensions, materials, care instructions, and safety notes to avoid product-related confusion.
• Damage/defect resolution: Set clear expectations around what qualifies as a defect and how customers can report it.
• Warranty or guarantee: Outline what’s covered, for how long, and how to claim it, especially important for durable goods.

At the end of each product page, BlenderBottle shares a support menu where shoppers can find information on order status and replacement parts. 

Where to share store policies

• Embed product-related FAQs directly on PDPs to answer questions where they arise.
• Use conversational AI assistants like AI Agent to automatically resolve tickets related to product questions and damaged orders.
• Add warranty and damage policy links in order confirmation and shipping emails to keep customers informed.

Read more: What's the secret to reducing WISMO requests?

3. Consumer electronics

In electronics, clarity is everything. Customers want to know how to use the product, what to do if it doesn’t work, and how to get a replacement — without jumping through hoops.

Over-the-counter hearing aid company Audien Hearing nails this by creating crystal-clear support content around setup, shipping, and returns, so customers can troubleshoot confidently and independently.

Key policies to prioritize

• Warranty/repairs: Explain what’s covered, how to file a claim, and turnaround times for repairs or replacements.
• Returns and exchanges: Clearly state the return window, list of eligible items, processing time, and whether you accept refunds, in-store credit, or exchanges.
• Shipping and delivery expectations: Share average delivery timelines and what to expect once a product ships.
• Troubleshooting steps: Provide self-service guides for common issues like connectivity, battery life, or setup confusion.

Audien Hearing has clear visual policies that make it simple for shoppers to find the info they need quickly. 

Where to share store policies

• In chat, set up an automated flow that answers questions like “How do I set this up?” or “Can I return this?”
• Let customers track their return or exchange process, especially when high-value items are involved.
• Create step-by-step guides, accompanied by video or images, in your Help Center for setup and basic troubleshooting.
• Include warranty and return information in the product packaging, so customers have it readily available in case something goes wrong.

4. Health and wellness

In the health and wellness space, trust and transparency are everything. Customers want to feel confident that the products they’re using are safe and that the support will be just as thoughtful as the product itself.

Brands like period underwear brand Saalt do this exceptionally well, pairing clear product education with empathetic policies that guide customers through everything from first use to subscription changes.

Key policies to prioritize

• Product safety and use: Provide detailed instructions, safety disclaimers, and FAQs for first-time users, especially for intimate or ingestible products.
• Returns (especially for hygiene items): Be upfront about what can and can’t be returned, and include compassionate language to build trust.
• Order change or cancellation: Make it easy to update or cancel orders, especially for items that ship quickly or automatically.
• Subscription FAQs: Clearly explain how to skip, pause, or cancel a subscription, and what benefits subscribers get.

Saalt lets customers phrase questions themselves or choose from a dropdown menu.

Where to share store policies

• Prioritize clarity on your contact form by using dropdowns or checkboxes to organize customer inquiries by topic.
• Let AI Agent handle recurring product questions like “How do I use this?” or “Is this safe?” to free up your team.
• Include shipping and return info in SMS flows so customers can get answers on-the-go, without needing to email.

5. Food and beverage

Food and beverage customers tend to be both curious and cautious. They want to know what they’re putting in their bodies — and what to do if something goes wrong with the order. 

Brands like Everyday Dose get ahead of these concerns by making their policies clear, accessible, and customer-first.

Key policies to prioritize

• Ingredient and allergen disclaimers: Transparency is everything. List ingredients, possible allergens, and sourcing details to build trust.
• Subscription changes: Give customers full control to pause, skip, or cancel deliveries with minimal friction.
• Damaged orders: Outline what customers should do if a product arrives broken or spoiled, and how fast they can expect a replacement.
• Shipping and delivery FAQs: Cover delivery timeframes, how orders are packed, and what to do if a shipment is delayed.

Everyday Dose lists frequently asked questions and makes it simple for customers to find important allergen and ingredient information. 

Given that Everyday Dose is a mushroom supplement brand, many shoppers will likely have questions around allergens and exact ingredients. On each of their product pages, there is a clear “Read the Label” button. 

Everyday Dose also has a chat which encourages customers to click through to the correct support link or to track their order. 

Where to share store policies

• Enable self-service order management on chat to give customers real-time updates on shipping status and subscription changes.
• Feature policy links prominently in your customer account portal — especially for managing subscriptions.
• Include your damage/return policy in post-purchase and thank-you emails, so customers know exactly what to do if something’s wrong.

Pro Tip: Use a conversational AI platform to handle common questions at scale. For example, Gorgias’s AI Agent can instantly respond to FAQs like “How much is shipping?” or “When will my order arrive?” — all in your brand’s voice. And when a request needs a human touch, it routes the ticket to the right agent automatically.

Best practices for writing and distributing store policies

Even the most well-written policy won’t reduce tickets if it’s buried three clicks deep in your footer. To truly support your customers (and lighten your team’s workload), your policies need to show up in the right places, at the right moments.

Here’s how to get them in front of customers when they need them most:

Surface policies across key customer touchpoints

• Product detail pages: Link to size guides, shipping timelines, or ingredient lists directly on PDPs.
• Chat: Use a combination of automated flows and conversational AI to proactively suggest relevant policies based on the customer’s question or page.
• Help center: Turn your most common ticket topics into easy-to-scan articles with clear titles and headers.
• Email flows: Include return and warranty info in post-purchase emails, shipping updates, and thank-you messages.
• Account portals: Make it easy for customers to manage subscriptions, view order policies, and find FAQs in their account dashboard.
• SMS or mobile support: Include quick policy reminders in transactional texts, like shipping delays or renewal reminders.

3 core elements of a strong store policy

1. Clear: Use plain language, short sentences, and bullet points. Avoid legal jargon.
2. Accessible: Link them prominently in your footer, header, Help Center homepage, chat, and product pages.
3. Actionable: Tell customers exactly what to do — where to click, who to contact, and what to expect.

Well-placed policies turn support into a self-service experience. They empower your customers to get what they need without ever opening a ticket — and that’s a win for everyone.

Turn store policies into your first line of support 

Clear, proactive policies do more than answer questions. They prevent tickets, build trust, and make your support team’s job easier. By tailoring your policies to your industry and placing them where customers actually need them, you turn potential friction points into smooth experiences.

Want to take it a step further? Book a demo to see Gorgias’s AI Agent handle common inquiries like shipping, returns, and product questions, across chat, email, and contact forms.

{{lead-magnet-2}}

If you're an ecommerce leader right now, you’re likely facing a new wave of uncertainty. Rising tariffs, disrupted imports, and sudden cost increases are putting pressure on your margins, and your customer relationships.

At Gorgias, we are working with thousands of brands that are grappling with tough calls: adjust prices, shift sourcing, or absorb costs to protect loyalty. And while the supply chain is where these issues start, the customer experience is where they play out.

Whether you’re a growing DTC or an enterprise brand, your customers deserve transparency. We know the pressure you're under, and we're here to help you navigate it. To help you not only manage the conversation, but lead it with clarity, empathy, and speed. 

Ecommerce brands are in an impossible position right now, following the 24 hours news cycle, and waiting to see how tariffs will cut into profits and impact their business. 

For customers? It can create confusion, frustration, and a flurry of angry tickets if brands aren’t proactive and transparent. But here's the truth: how your team talks about tariffs is just as important as what they say.

These moments of friction, and how you communicate these changes to your customers can be opportunities to build trust, reduce churn, and even demonstrate the real revenue power of your team. In a moment when clarity and trust are everything, the role of CX leaders is more important than ever. 

When tariffs hit, CX takes the call

Tariffs may seem like a back-end issue, but in reality, they shape front-end experiences—from product pricing and availability to fulfillment speed and satisfaction.

For ecommerce brands, especially those sourcing from China or shipping globally, these trade shifts hit close to home. Products get more expensive, shipping slows down, and some SKUs disappear altogether.

And CX teams are often the first to hear about it. The question isn’t if you should communicate tariff implications, but how.

What customers actually want to know 

Here’s the good news: customers don’t expect you to control global trade policy. But they do expect honesty.

What matters most right now is:

• Transparency: Be clear about what’s changing and why.
• Timing: Tell them before they find out at checkout.
• Empathy: Acknowledge that increased prices or delays are frustrating and explain what you're doing to help.

And even more specifically, your customers are likely looking for answers to three simple questions: 

1. Did the price increase? Why? 
2. Why can’t I find this product anymore? 
3. Is my order going to be delayed? 

In times of change, trust becomes foundational. If you're not upfront about what’s happening and how it affects them, customers will fill in the blank, or worse, turn to competitors. 

How to talk tariffs without losing trust 

Be clear, not complicated

Tariffs are complex, but your messaging shouldn’t be. Strip out the policy jargon and explain the changes in human terms. Let customers know what’s changing, why it’s happening, and what steps you’re taking to protect their experience.

Instead of: “Due to regulatory changes impacting import duties…”

Say: “Because of new tariffs, some of our prices have gone up. Here’s why, and what we’re doing to keep costs down.”

Say the same thing everywhere 

From your Help Center to your agents to your email updates, your message should be consistent. Mismatched explanations create confusion and erode trust. Align your team on the key talking points and update scripts and automations across all customer touchpoints.

Speaking of your Help Center, now might be a great time to create an article specifically about tariffs and how you’re approaching them. The article can serve as a source of truth for your customers and your AI agents on the front lines answering questions.

Lead with empathy

Customers don’t just want the facts, they want to know you care. Acknowledge the frustration, and offer reassurance. Small gestures like a personalized note or a shipping perk can show you’re on their side.

Be specific and honest 

Generic messages fall flat. Give customers details that they can rely on: Are the changes permanent? Are you absorbing part of the cost? Is a specific product impacted? When you’re upfront about the situation, and how you’re responding to it, you build credibility.

Decide how AI Agents should help

Times of uncertainty are times to cut costs, but it may also mean increased ticket volume. AI agents can help on the frontlines. But be sure to build your handovers to escalate to your team in the right moments to build trust.

Start with transparency: Beis sets the bar

Luggage brand, Beis, recently sent an email to customers that is a great example in customer-first communication. Rather than quietly raising prices or burying fees in checkout, they called it what it was: tariffs.

They explained the change clearly, why it was happening, and what customers could expect. And most importantly, they acknowledged the frustration. No spin, or vague language, just a clear message from a brand that respects its customers enough to be honest with them.

This kind of proactive messaging does more than prevent a flood of support tickets. It creates alignment between the brand and the customer. Beis didn’t make the rules but they’re navigating them with their customers, not in spite of them.

Make it a CX conversation, not just a policy page 

Too often, tariff policies get relegated to the FAQ page or terms and conditions. Customers typically only land there after they’re already confused or upset.

Instead, CX should treat tariffs as a key part of the customer journey and be equipped to speak about them empathetically and clearly. 

1. Proactive chat leads to fewer surprises

Add a proactive message to your chat widget that addresses tariff-related questions before they even come up. A short note like, “You may notice some pricing changes – here’s why,” with a link to your FAQ or a specific article, helps to deflect confusion and prevents cart abandonment. 

2. Update your FAQ with key information 

Surface timely information right where customers are most likely to look. Use your chat or search function to include a clear callout. 

“Looking for information on recent pricing or shipping updates? Here’s what changed.” 

This type of visibility empowers self-service, and reduces ticket volume. 

3. Equip your agents with scripts that are genuine 

Don’t leave your support team guessing. Create internal scripts with clear language on what to say (and what to avoid) when talking tariffs. Script empathy, not just compliance: Empower agents with language that acknowledges the inconvenience while reinforcing the brand's values.

Say: 

• We’ve made some pricing updates due to new tariffs, and we’re doing everything we can to minimize the impact. 
• We know this change may be frustrating. Here’s how we’re helping our customers through it. 

Avoid: 

• Overly technical or vague terms like “regulatory adjustments” or “economic climate shifts.” 
• Any messaging that deflects responsibility or blames external factors without explanation. 

4. Build smart macros for Tariff FAQs

If you’re using automation, make sure your AI Agent and autoresponders can explain tariff policies accurately and compassionately. Use macros to ensure fast, consistent replies, without sacrificing tone. Some key macro themes to create: 

• Why did prices increase? 
• Are tariffs permanent? 
• Is my order delayed because of tariffs? 
• Why is this product no longer available? 

Each macro should strike a balance of clarity, empathy, and brand voice, offering both the what and the why. 

You can’t control tariffs. But you can control trust. 

Tariffs might be out of your control. But how you talk about them? That’s entirely in your hands.

This is your moment as a CX leader, not just to react but to lead. To turn friction into transparency, tension into trust, and confusion into connection. Because when policies change overnight and customer confidence is on the line, the brands that communicate with honesty, consistency, and care don’t just survive. They strengthen loyalty.

Your customers don’t expect perfection. They expect clarity. They expect empathy. And they expect you to show up.

At Gorgias, we’re here to make sure you can. With tools to automate answers, personalize conversations, and empower your team to deliver the kind of CX that builds long-term brand equity, even when times get tough.