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:

• 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.

TL;DR:

• Most chargebacks occur due to poor merchant communication rather than fraud. Customers choose this path when they feel ignored or frustrated.
• 80% of customers report never being contacted by merchants after filing a chargeback. 23% file immediately after an issue and 38% file within 1-3 days if unresolved.
• The most common chargeback reason is "product not received" (35%). 79% of all chargebacks are actually "friendly fraud" filed for invalid claims.‍
• Prevention requires fast customer support and automated chargeback management. Combining Gorgias for AI-powered support with Chargeflow for automated dispute management provides a comprehensive solution with faster resolutions and higher win rates.

Chargebacks are more than a thorn in a merchant’s side — they’re a growing financial and operational threat. According to Ethoca, chargebacks are projected to more than double, from $7.2 billion in 2019 to $15.3 billion by 2026 in the U.S. alone. And while fraud plays a role, the primary reason customers file chargebacks is simpler: they feel ignored. 

At Chargeflow, we recently published a comprehensive report analyzing why customers dispute chargebacks. The findings were eye-opening. While it’s true that fraud is a real concern, most chargebacks happen for a different reason: a lack of communication between merchants and customers.  

Top stats from Chargeflow’s report:

• 23% of customers file a chargeback immediately after an issue.
• 38% file a chargeback within 1-3 days if unresolved.
• 80% report never being contacted by the merchant.
• 52% are likely to dispute if the response is too slow.

When customers feel ignored or frustrated, they often turn to their bank for a solution instead of reaching out to the merchant first. Understanding these behaviors is key to preventing disputes before they escalate and cause chaos. 

So, what actually drives customers to dispute charges? Here’s what the data says.

Why customers file chargebacks

While chargebacks are often the cost of doing business, the truth is that many disputes are preventable — but only if merchants understand the root causes. We identified five key drivers behind chargebacks.

1. Customers take immediate action

According to our research, most customers file a dispute right away after encountering an issue, leaving no opportunity to resolve the problem. Another 38% file within one to three days if they don’t receive a timely response. 

Why? Customers assume the fastest way to get their money back is by filing a chargeback, especially if they receive no response from the merchant.

2. Lack of communication leads to disputes

We found that 80% of customers never receive a follow-up after filing a chargeback. Additionally, 64% of customers state immediate communication is crucial, yet many businesses fail to reach out.

• 90% of customers tried to reach out to the merchant first.
• If they don’t receive a response, they quickly file a dispute. 

Why? Customers expect businesses to be proactive. When they don’t hear back quickly, they assume the merchant won’t help, making a chargeback seem like the best option.

3. Chargebacks are too easy for customers

98% of customers report a neutral to highly satisfactory experience when filing chargebacks, and only 12% are denied. 

Why? Many customers believe chargebacks are faster and easier than dealing with merchants directly, especially if return policies are unclear. 

4. Transaction issues drive chargebacks

The most common reason for filing a chargeback is “product not received” (35% of the cases). Other common reasons included:

• Fraudulent transaction claims - 16%
• Product significantly not as described - 15%
• Unauthorized transaction - 15%

Why? When customers don’t receive clear shipping updates or experience delivery delays, they assume their order won’t arrive and file a chargeback rather than waiting.

5. Friendly fraud is a major problem

Friendly fraud occurs when a cardholder makes a legitimate purchase but later disputes the charge as fraudulent or unauthorized, leading their card issuer to reverse the payment. 

Our research found that:

• 21% of customers admitted to not fully understanding the chargeback process. 
• Another 20% aren’t even aware of what a chargeback is. 
• 97% of consumers believe they’ve never filed a chargeback incorrectly, while only 3% admit they have.

According to our State of Chargebacks report, 79% of chargebacks are actually friendly fraud, meaning they were filed for invalid reasons.

Why? Many customers mistakenly believe that a chargeback is just another way to request a refund, rather than a process intended for fraud or merchant failure. 

📌 The takeaway: Most chargebacks aren’t actual fraud, but rather a result of customer confusion, impatience, or poor communication from merchants.

The solution: how to stop chargebacks before they happen

Merchants who want to stop chargebacks before they happen need a two-part strategy:

• Fast, customer-focused support to resolve issues before customers dispute charges. 
• Automated chargeback management to detect and fight disputes efficiently, so merchants don’t lose revenue to invalid claims.

Chargebacks result from slow response times, poor communication, and unresolved issues, not fraud. Adopting AI-driven customer support and chargeback automation allows businesses to significantly reduce disputes and retain more revenue. 

How AI-powered support & chargeback automation work together

Instant responses prevent frustration-driven chargebacks

Many chargebacks happen because customers don’t receive a fast enough response. In fact, 52% say they will dispute a charge if the response time is too slow. AI-powered chatbots provide real-time support, resolving issues before they escalate. 

Proactive communication reduces uncertainty

Customers expect updates regarding orders and refunds, but often don’t receive them. 80% of customers report never hearing from a merchant after filing a chargeback. 

Automated order updates, refund confirmations, and proactive notifications keep customers informed, reducing unnecessary disputes.

24/7 availability ensures no issues go unanswered

Customers expect round-the-clock support, but most businesses can’t provide live assistance. AI-powered ticketing and automation ensure every customer receives help, regardless of the time zone or urgency.

The result? Fewer chargebacks, faster resolutions, and increased customer satisfaction.

Actionable strategies for improving response times

Prioritize long-term clients

It’s impossible to please every customer. On average, chargebacks take 50 days to resolve successfully. Focus your energy on retaining high-value, long-term customers.

Prioritize high-risk inquiries

Lost inquiries take on average 15 days to resolve, and lost chargebacks take 38 days. Prioritize cases based on impact. 

Build efficient escalation systems

Advanced automated ticketing systems can route inquiries and prioritize urgent cases.

Use pre-approved resolution templates

Ensure customer service teams have quick-response templates to speed their resolutions.

Work closely with shipping carriers

“Product not received” was the most cited reason for delivery-related chargebacks. Work closely with carriers and third-party suppliers to improve fulfillment and reduce disputes.

Leverage chargeback management tools

Use automated tools for real-time analytics, enhanced communication, and proactive alerts, which will reduce response times. 

Gorgias & Chargeflow: A fully automated chargeback prevention system

Successfully tackling chargebacks requires both proactive customer support and automated dispute management. That’s why Gorgias and Chargeflow work so well together to give merchants a comprehensive defense against disputes.

Post-purchase automation isn’t just about reducing customer support workload or quick replies. It's about finding the most effective ways to increase customer loyalty and prevent disputes.

Learn more about how AI-driven automation enhances post-purchase experiences here.

How Gorgias prevents chargebacks with conversational AI

• Automated real-time responses engage customers before they decide to dispute charges.
• Proactive customer communication ensures customers receive updates on their orders, refunds, and transactions.
• 24/7 availability ensures customers receive the support they need without increasing overhead. 

How Chargeflow automates chargeback prevention & recovery

• Pre-dispute alerts notify merchants before a chargeback is finalized and provide proactive intervention.
• AI-powered chargeback responses to automate evidence collection and improve win rates. 
• Smart analytics to help merchants understand why disputes happen and how they can prevent them. 

Final thoughts: Stop chargebacks before they start

As you know, chargebacks are costly, frustrating, but most importantly, preventable. Our research shows that most chargebacks don’t stem from fraud, but from poor communication, slow response times, and customer uncertainty.

By prioritizing fast, AI-driven customer support and automated chargeback management, merchants can resolve issues before they escalate, improve customer experience, and protect their revenue. 

With Gorgias handling proactive customer support and Chargeflow managing chargeback disputes, merchants get a powerful, end-to-end prevention system that ensures fewer chargebacks, higher dispute win rates, and, at the end of the day, happier customers. 

Don’t let chargebacks drain your revenue. Take control today with faster, smarter automation.

Download Chargeflow’s full Psychology of Chargebacks Report to dive deeper into the data and start preventing disputes before they happen.