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:

• Actions are tasks automatically performed by AI Agent for customers. From address changes and subscription pauses to order cancellations, Actions can fulfill requests for your customers, even when your human agents are offline.
• Actions connect directly to your ecommerce apps. Currently, Actions have native integrations with Shopify, ShipMonk, ShipHero, ShipStation, Stay AI, Recharge, Loop, Subscriptions by Loop, Skio, Seal Subscriptions, and Wonderment.
• Use pre-built Actions or build your own. There are 12 Action templates available, or you can build Actions using custom HTTP requests.
• Watch out for setup snags. Conflicting Guidance, multiple matching Actions, older orders, or broken logic can block an Action from executing.

Automated responses don’t actually resolve anything. In reality, they increase customer wait time.

What a customer really wants is immediate resolution, whether they’re looking to cancel an order, change a shipping address, or pause a subscription.

So, how do you go beyond automated text responses? AI Agent Actions. 

Below, we’ll go over the 7 most common customer service requests you can resolve with AI Agent Actions, so your team gets time back to strengthen customer relationships, increase revenue, and improve your CX strategy. 

{{lead-magnet-1}}

What are AI Agent Actions?

AI Agent Actions are tasks AI Agent can complete for your customers, such as canceling an order or updating a shipping address. 

Instead of handing it off to a human agent, AI Agent resolves the ticket by connecting to your ecommerce apps and performing the action on its own.

You get maximum control over when and how Actions are executed. Before performing the Action, AI Agent asks customers for confirmation, respecting your processes and maintaining a high level of customer service. Once an Action has been taken, you can even share feedback with your AI Agent to reinforce its behavior or finetune it further.

Pro Tip: Unlike Guidance, which tells AI Agent how to respond in a conversation, Actions determine what happens. It’s the difference between saying “I’ll refund your order” and doing it.

Related: How AI Agent works & gathers data

Top 7 customer requests you should be automating with AI Agent Actions

Ready to resolve requests in seconds? Activate these pre-built Actions in Gorgias to keep your team efficient and your customers happy. 

1. Customer wants to update their shipping address

Action to use: Update shipping address

Supported apps: Shopify, ShipMonk, ShipHero, ShipStation

Incorrect shipping addresses lead to costly re-shipments, delays, and even refunds. Catch errors early to keep customers satisfied and excited about their order.

Why do you need this Action? 

The reality is your agents aren’t available 24/7. Unless you hire a team to cover night and weekend shifts (which is unlikely), requests will be missed. AI Agent fills in that gap, handling time-sensitive issues when your team is off the clock. Missing them isn’t just about poor customer experience—it can also lead to extra costs, like reshipping orders.

2. Customer wants to cancel an order

Action to use: Cancel order 

Supported apps: Shopify, ShipMonk, ShipHero, ShipStation

Perhaps a customer ordered the wrong item, chose the wrong size, used the wrong card, or simply changed their mind. Allow them to quickly cancel their order and receive a refund in one go.

“Actions responds to tickets within about 30 seconds and is available 24/7. Regardless of when a customer places their order, the likelihood of quickly catching and canceling the order has increased by 70% since we started using Actions. It’s an exceptional result."

—Jon Clare, VP of Customer Service at Trove Brands

3. Customer wants to replace/remove an item in their order

Actions to use: 

• Replace item, or 
• Remove item

Supported app: Shopify

It happens—shoppers order the wrong size or color and want to change their order immediately. Regardless of the reason, make their new decision easy to implement. Quick, accessible order updates prevent returns, lost revenue, and, most importantly, customer disappointment.

Here’s what the replace order item setup looks like in Gorgias:

Pro Tip: If you have unique workflows, you can create advanced, multi-step Actions and connect to your tools beyond our default integrations. This option requires some tech know-how (like custom HTTP requests), so feel free to bring in your developers for assistance.

4. Customer wants to skip or pause a shipment

Actions to use:

• Skip next subscription shipment, or
• Pause subscription

Supported apps: Stay AI, Recharge, Subscriptions by Loop, Skio, Seal Subscriptions

Subscriptions shouldn’t be all or nothing. Let customers skip a shipment or pause their subscription, so they can come back when they’re ready. Giving them full control lets them manage their subscription on their own terms, reducing churn rate in the process.

Here’s how AI Agent handles a skip shipment request: 

5. Customer lost or damaged their order in transit

Action to use: Reship order for free

Supported apps: Shopify, ShipMonk

No customer expects a lost or damaged order. Let customers know that you have their backs by reshipping a new order free of charge. Fast resolutions during unexpected events demonstrate your commitment to customer satisfaction.

“An instant response builds confidence. We live in a world with short attention spans, so customers appreciate how quickly we can respond to their inquiries. Customers aren’t worrying unnecessarily for longer than they have to for an address change or order cancellation.”

—Mia Chapa, Sr. Director of Customer Experience at Glamnetic

6. Customer wants to know their return shipping status

Action to use: Send return shipping status 

Supported app: Loop

Customers want to know that their return package is on its way to you, so they can redeem their refund. Easily send them a shipment tracking link to give them that peace of mind.

7. Customer wants to know about order status

Action to use: Get order info 

Supported apps: Shopify, ShipHero, ShipMonk, ShipStation, ShipBob, Wonderment

Based on Gorgias data, order status ranks among customers' top 10 questions for support teams. Reassure your customers with quick updates on their orders, including product details, shipping progress, expected delivery date, and other helpful information.

What to know before turning on Actions

Here are a few helpful setup tips to make sure Actions run without a hitch:

• Guidance can override Actions. If conflicting Guidance exists, it may prevent an Action from triggering, even when all conditions are met. Review your Guidance to avoid overlaps, or write your logic into the Action description instead.
• Any Action that changes data requires shopper confirmation. Actions like canceling orders, updating addresses, or canceling subscriptions mean AI Agent will always ask the shopper to confirm before making a change.
• Currently, only one Action can run per ticket. If multiple Actions qualify, none will run, and the ticket will be handed off. Use conditions carefully to ensure only one Action matches per use case.
• AI Agent can only access the shopper’s last 10 orders. If the customer references an older order, the Action won’t trigger and the ticket will be handed over for manual handling.

AI Agent Actions speak louder than words

If you want…

• Fewer repetitive tickets
• Faster customer support
• Happier customers who get what they need instantly
• More time for your team to strategize
• Lower costs and higher efficiency

AI Agent Actions can get you there.

You’ve now seen how Actions can resolve tickets in a snap—no unnecessary handoffs, canned responses, or long response times.

Book a demo to see AI Agent Actions work in real time and start automating what you shouldn’t be doing manually anymore.

{{lead-magnet-2}}

TL;DR:

• AI Agent is only as good as the instructions you give it. Clear Guidance enables it to perform like your best support teammate.
• The “When, If, Then” framework makes writing Guidance easy and repeatable. Start with the scenario (when), define the conditions (if), and list specific actions (then) to create structured Guidance.
• Use Guidance to handle frequently asked questions, like returns, cancellations, or discount code inquiries, so your team can focus on more complex issues.
• If your Guidance isn’t working, formatting or logic gaps might be to blame. Check for missing conditions, unsupported tasks, or confusing formatting.

AI Agent is built to deliver fast, accurate support at scale, but like any teammate, it performs best when given clear and specific instructions. 

That’s where Guidance comes in. Writing structured prompts that tell your AI Agent exactly what to do in a given scenario helps reduce escalations, speed up resolutions, and create a more consistent customer experience. 

One simple, repeatable way to do that is with the “When, If, Then” framework. 

In this post, we’ll show you how it works, using examples from our Gorgias Academy course, Improve AI Agent with Better Guidance. 

You’ll learn how to write Guidance that results in:

• Fewer escalations
• Faster resolutions
• Smarter, more consistent AI behavior

Let’s break it down.

{{lead-magnet-1}}

What is Guidance?

Guidance is how you tell your AI Agent what to do. It’s a set of instructions that outlines how your AI Agent should respond in specific situations. 

When Guidance is available, your AI Agent follows it first, even before checking your Help Center or website content.

That means if your Guidance is missing, unclear, or incomplete, your AI Agent might escalate the ticket, or worse, give a confusing or unhelpful response. Here’s an example:

Let’s say a customer wants to return an item. A human agent would send them a link to the return portal and explain the steps. But without that instruction in Guidance, your AI Agent might skip straight to escalation, turning a simple request into unnecessary work for your team.

That’s why clear, step-by-step Guidance is key to help your AI Agent respond the way your best support agent would.

Learn more: Create Guidance to give AI Agent custom instructions 

Introducing the “When, If, Then” framework

Sometimes it’s hard to know where to start when writing Guidance. The “When, If, Then” framework gives you a simple, repeatable structure to follow, so there’s no need to guess. 

Taking this approach mirrors how AI Agent processes information behind the scenes. When you write clear Guidance, your AI Agent can follow it step by step, just like a support teammate would.

Let’s walk through the three parts of the framework.

WHEN: Set the scenario

Start by identifying the situation your Guidance applies to. This is the trigger or scenario. Use it as the title of your Guidance so it’s easy to find later.

Example:

• WHEN a shopper asks to return an order
• WHEN a customer wants to cancel their subscription

Keep it simple and action-oriented. You’re setting the stage for what comes next.

IF: Add conditions

Once you’ve defined the scenario, add any conditions that determine what should happen. “If” statements help your AI Agent understand what to do based on specific details, like timing, order history, or customer tags.

Example:

• IF the order was placed less than or equal to 15 days ago
• IF the customer has a VIP tag in Shopify

Use as many “if” conditions as needed to guide different outcomes. Just make sure you cover all the possibilities so your AI Agent doesn’t get stuck.

THEN: Define the actions

This is where you tell your AI Agent exactly what to do. Be specific and use bullet points or numbered steps to keep things clear.

Example:

• Tell the shopper they’re eligible for a return
• Send them a link to the return portal
• Let them know they’ll receive a prepaid label once the form is submitted

The more clearly you outline the steps, the more consistently your AI Agent will perform.

The framework keeps your Guidance simple, structured, and easy to understand—for both your team and your AI Agent. When your AI Agent knows exactly what to do, it can deliver fast, accurate, and helpful responses that keep customers happy.

Put it all together

Say a shopper messages your store asking to return an item and you want AI Agent to send them to your return portal.

Here’s how this looks in a complete piece of Guidance:

WHEN a shopper asks to return an order:

IF the order was placed less than or equal to 15 days ago,   

THEN

• Tell the shopper they’re eligible for a return
• Send them a link to the return portal
• Let them know they’ll receive a prepaid label via email once they submit the form

9 support scenarios made better with Guidance

These nine scenarios come up constantly in ecommerce support, and they’re perfect candidates for automation. They follow predictable patterns and are quick to resolve when your AI Agent knows what to do.

Use the examples below to jumpstart your setup. Each one is written using the When, If, Then framework and can be copied directly into Gorgias.

1. Where’s my order? (WISMO)

WHEN a customer asks about their order status:

IF tracking information is available,

THEN

• Provide the tracking number and link to the carrier's tracking page.
• Inform the customer of the expected delivery date.

IF tracking information is unavailable,

THEN

• Inform the customer that the order is being prepared for shipment.
• Provide an estimated shipping date.

2. What size should I order?

WHEN a customer inquires about product sizing for [item name]:

IF the customer asks what size to get, or mentions they’re unsure about sizing,

THEN

• Share the sizing chart or guide.
• Offer recommendations based on common fit feedback.

3. Can I change my shipping address?

WHEN a customer requests to change their shipping address:

IF the order has not been fulfilled,

THEN

• Confirm the new address with the customer.
• Update the shipping address in Shopify (or your chosen platform).

IF the order has already been fulfilled,

THEN

• Inform the customer that the address cannot be changed.
• Provide options for order interception or return.

4. Can I cancel my order?

WHEN a customer asks to cancel their order:

IF the order has not been fulfilled,

THEN

• Confirm that we can cancel their order.
• Tell them they’ll receive their refund in 5-10 business days.

IF the order has already been fulfilled,

THEN

• Inform the customer that the order cannot be cancelled.
• Help to initiate a return once the item is delivered.

5. How do I return an item?

WHEN a customer asks about returning an item:

IF the return is within the allowed return window of [x] days after the order was received,

THEN

• Provide the return instructions and link to the return portal.
• Inform the customer about the refund process.

IF the return window has expired,

THEN

• Inform the customer that the return period has ended.
• Offer alternative solutions if available.

6. Do you have any discount codes?

WHEN a customer inquires about discounts or promo codes:

IF there is an active promotion for [item name],

THEN

• Share the current discount code and its terms.

IF there are no active promotions for [item name],

THEN

• Inform the customer that there are no current promotions.
• Suggest subscribing to the newsletter or following social media for future promos.

7. I want to pause my subscription.

WHEN a customer requests to pause their subscription:

IF the customer has an active subscription,

THEN

• Provide instructions on how to pause the subscription through their account.
• Confirm the pause and inform them of the next billing date.

8. When will this item be back in stock?

WHEN a customer asks about product restocking:

IF a restock date is available,

THEN

• Inform the customer of the expected restock date.

IF the restock date is unknown,

THEN

• Offer to notify the customer when the product is back in stock.
• Suggest similar products.

9. Do you ship internationally?

WHEN a customer inquires about international shipping:

IF international shipping is available,

THEN

• Confirm that international shipping is offered.
• Provide estimated delivery times and any additional fees.

IF international shipping is not available,

THEN

• Inform the customer that shipping is limited to specific regions.

Pro Tip: Test out your Guidance by going to AI Agent > Test, and iterate as you go.

Troubleshooting: Why Guidance might not trigger

If your AI Agent isn’t following your Guidance, or it’s escalating tickets you thought it could handle, run through this quick checklist to spot the issue:

• Has a descriptive, easy-to-understand name: Name your Guidance based on the scenario (e.g. When a shopper asks about returns).
• Clear IF and THEN conditions: Make sure your Guidance spells out what to do when a condition is met.
• Covers all variations (no gaps in logic): Don’t leave your AI Agent hanging. Include fallback instructions for all scenarios.
• No wall-of-text formatting: Break things up with line breaks, headers, and spacing to help AI Agent scan quickly.
• Clearly written steps with bullets or numbers: Use lists to make actions easy to follow, like you would for a teammate.
• Doesn’t include unsupported tasks: Avoid unsupported instructions like “send macro,” “assign to agent,” or “delay the response.”

Bonus: Let AI do the heavy lifting

Don’t have time to write Guidance from scratch? The good news is AI can help with that, too.

AI-generated Guidance is available for all AI Agent subscribers. This feature analyzes your historical ticket data and uses it to generate ready-to-use, customizable prompts for your AI Agent.

Here’s what it does:

• Analyzes past tickets to identify common support scenarios
• Generates step-by-step Guidance based on what’s worked before

Ready to level up your Guidance?

Clear, structured Guidance is the key to unlocking better performance from your AI Agent. With just one well-written “When, If, Then” prompt, you can reduce escalations, speed up resolutions, and give your shoppers a smoother experience.

Not sure where to start? Try writing Guidance for one common question today—like returns, order status, or promo codes. Or, if you want to go deeper, check out our free Gorgias Academy course. 

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