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 helpdesk shouldn't hold you back. If your team is buried in tickets or bouncing between tools, your platform might be the problem—not your process.
• Rising ticket volumes, slower response times, and clunky integrations are signs you’ve outgrown your platform. Don’t wait for these issues to impact revenue or retention.
• You’re not alone—fast-growing brands hit these roadblocks too. Dr. Bronner’s, Psycho Bunny, and Audien Hearing all switched platforms to support bigger growth with less friction.
• Helpdesk migration doesn’t have to be scary. With the right migration support, you can move quickly, avoid downtime, and give your team a tool they actually want to use.

As ticket volume grows, even the best CX teams start running into roadblocks: limited integrations, repetitive manual work, clunky interfaces, and slower response times. You patch things together. You make it work... until you can’t.

Many growing ecommerce brands find themselves trapped in a system that demands constant workarounds just to function.

If your current customer service platform feels more like a burden than a backbone, you’re not alone—and you’re not stuck.

In this post, we’ll walk through:

• The key signs it’s time to switch platforms
• What to prioritize when choosing your next one
• How brands like Pepper made a smooth move to Gorgias

The 5 warning signs you’ve outgrown your helpdesk

There’s a tipping point most brands hit as they scale. The signs are subtle at first—maybe your agents are taking longer to respond, or the volume of customer support tickets quietly outpaces your team. Then it starts affecting revenue, customer satisfaction, and retention. Big yikes.

Left unchecked, small inefficiencies can snowball into bigger operational challenges.

Catch these warning signs before they start costing you growth:

1. Rising ticket volume and slower resolution times

Support teams that are always playing catch-up rarely have time to focus on higher-value work. If your inbox is constantly overflowing or first response times are creeping up, it’s likely a sign your tools aren’t scaling with your business.

That’s exactly what happened with apparel brand Psycho Bunny.

“As we grew and expanded, we needed a tool that was better suited for Shopify, easier to manage, and offered better support to help us get the most out of the tool,” said Jean-Aymeri de Magistris, VP IT, Data & Analytics, and PMO at Psycho Bunny.

2. Agents constantly toggling between tabs and tools

If your agents are spending more time gathering context than solving problems, you’re losing time (and likely, patience) on both sides of the conversation. Fragmented tools can seriously undercut productivity.

Dr. Bronner’s experienced this firsthand, juggling Salesforce, spreadsheets, and disconnected systems.

“When I joined, we were logging calls and emails in Excel. It wasn’t scalable,” recalled Emily McEnany, Senior CX Manager at Dr. Bronner’s.

3. Clunky or missing integrations with your ecommerce stack

Some platforms require technical support even for small changes, such as custom workflows, new automations, or basic integrations. That may work at the start, but it becomes a bottleneck as your brand grows.

Disconnected systems strip away context, increasing the risk of mistakes. Whether it’s pulling up an order status or managing a return, agents need tools that work together, not against each other.

4. You’re stuck answering the same questions over and over

Every support team deals with repetitive inquiries. But without automation or self-service options, those tickets eat into your team’s time and keep you from focusing on higher-impact conversations.

Nude Project struggled to keep up with their ticket volume due to Zendesk’s lack of intuitive automation features. During Black Friday, the team received a record-high number of tickets—more than double their average volume.

“Connecting with customers through a screen is not always easy. With the high volume of messages, we need a tool that simplifies operational tasks while enabling effective communication and organization,” said Raquel J. Méndez, CX Manager at Nude Project.

5. Onboarding takes too long

Your platform should be easy for new hires to learn and for your team to evolve with. If ramping up agents takes weeks (or months), the platform might be getting in the way more than it’s helping.

Arcade Belts went through this process, trying one system, then switching back to one that better matched their needs.

“It just took a demo or two to realize what was actually going to support our team the way we needed,” their Ecommerce Coordinator, Grant, shared.

If any of these challenges sound familiar, you’re not alone. 

The important part is recognizing when you’ve outgrown your current setup—and knowing that there are options out there to help you move faster.

What to look for when switching CX platforms

Switching platforms isn’t just about solving today’s problems. It’s about creating space for your team to be efficient, serve customers better, and turn support from a cost center into a real growth engine.

Need to migrate to a new platform? Look for the following:

1. A system that keeps up with rising ticket volumes

As your brand grows, support volume naturally increases. 

Find a stable infrastructure that can handle that growth, has zero platform lag, and a robust engineering team that continuously makes the tool better for your needs.

To Psycho Bunny, Zendesk was a “legacy tool”—so they switched to Gorgias.

In just a few weeks, they migrated all historical conversations, tags, and Macros to Gorgias. Jean-Aymeri, their VP IT, credits Gorgias’s helpful onboarding specialists for making it effortless to integrate their apps and onboard their team onto a brand new tool.

Related: The engineering work that keeps Gorgias running smoothly

2. Automation for repetitive tasks (that maintains the human touch)

From “where’s my order” questions to return policies, prioritize AI tools that can automate repetitive inquiries.

Dr. Bronner’s implemented AI Agent to handle rising volumes of FAQs, allowing their team to focus on complex requests that require a human touch.

In just two months, they saw:

• 45% of all customer service tickets automated
• $100,000 saved per year by switching from Salesforce to Gorgias
• 4 days per month in team time savings
• 11% higher customer satisfaction score 

By systematizing the simple stuff, they freed up bandwidth to focus on what matters most—building relationships and solving more nuanced problems.

3. Built-in features that turn support into sales

More brands are rethinking how support contributes to revenue. Look for a tool that combines support and sales. The most effective ones use AI to initiate upselling conversations, so your team can generate new revenue without needing to scale headcount at the same rate.

For jewelry brand Caitlyn Minimalist, which normally saw 30,000 tickets per month, AI Agent was the perfect fit. On top of answering FAQs, AI Agent also helped recommend products based on customer needs.

These conversations often begin as simple inquiries (“What should I get for my friend’s birthday?” or “What product suits me?”) and end in a purchase—handled entirely by AI. In fact, AI Agent’s conversion rates were 150% higher than the team average, proving that automation can support and sell.

4. A more efficient workflow—without relying on developers

The last thing scaling brands should have to worry about is relying on developers for basic changes. That includes being able to create macros and automations in-house and access key customer data without toggling across tools. 

The platform should fit into your existing ecommerce stack—not fight against it.

That’s where Audien Hearing found themselves before switching to Gorgias.

“I’ve seen companies lose a lot of money because it’s not efficient,” said Zoe Kahn, former VP of CX. “You try to save money early on, but then you look at your helpdesk a year later and think, ‘Oh no, what’s happening?’”

Since switching from Richpanel, Audien Hearing’s CX team has been able to run CX on their own terms—without the bottlenecks.

They now resolve 9,000 tickets per month through self-service alone (including a customer knowledge base), cut first response times by 88%, and reduced return rates by 5%. With more time for one-on-one conversations, CSAT jumped from 80 to 86.

What migration actually looks like

“But migration sounds hard.”

We get it. Moving your entire CX operation can feel intimidating. But with the right partner (and the right platform), it doesn’t have to be.

Here’s how Gorgias makes switching smooth and stress-free:

• A dedicated onboarding team: Our team is with you every step of the way—from initial setup to post-launch optimization.
• A platform built for ecommerce workflows: Gorgias is designed to work the way ecommerce brands do, not the other way around.
• Fast setup and agent training: Most brands are up and running in days, not weeks. And because the interface is intuitive, teams can get comfortable quickly without heavy, time-consuming training.
• Full data migration support: Whether you’re moving from Gladly, Zendesk, or another platform, we’ll help you bring your history, macros, and workflows over smoothly.

Most Gorgias customers are fully live within just a few days—ready to serve customers faster, smarter, and with less manual lift.

How Pepper made a smooth switch to Gorgias

When fast-growing intimates brand Pepper outgrew their old CX platform, they knew they needed a system that could scale with them—without sacrificing speed or quality.

“Gladly didn’t offer any automation or inbox organization features. Our queue got really messy. We got 400 tickets a day during Black Friday, and we didn’t clear that backlog until the following Spring. We knew we couldn’t do that again,” explained Gabrielle McWhirter, CX Operations Lead at Pepper.

With Gorgias, Pepper was able to:

• Fully migrate their workflows and history
• Train their team quickly on the new platform
• Launch their AI Agent ("Penelope") to automate more than 50% of support tickets

And the results spoke for themselves:

• 16.5x ROI on AI-driven sales interactions
• 90%+ decrease in first response and resolution times
• 18% uplift in average order value

See how Pepper made the switch happen (and why they’re never looking back):

Is it time to make the switch?

If you’re seeing the warning signs, here’s a quick gut check:

• You’re drowning in tickets and toggling between tabs
• You can’t track or tie support to revenue
• You need better integration with your tech stack
• You’re not using automation, or it’s not actually saving time
• Your team dreads logging into your current tool

The right platform won’t just help your team work better. It’ll help you drive more revenue, boost customer retention, and actually make customers want to talk to you.

See what switching to Gorgias could do for your brand. Book a demo today.

{{lead-magnet-1}}

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}}