Use case
Automating Abandoned Cart Recovery
Timed email sequences that bring shoppers back — without building a marketing automation platform.
Use case
Timed email sequences that bring shoppers back — without building a marketing automation platform.
The average cart abandonment rate across e-commerce sits around 70%, according to data from the Baymard Institute compiled across 49 studies. That means for every 10 shoppers who add something to their cart, 7 leave without completing the purchase.
The dollar figures are staggering. If your store does $1M in completed sales, roughly $2.3M worth of carts were abandoned to get there. Even recovering a small fraction of that — say 5–10% — adds meaningful revenue with no additional customer acquisition cost.
Abandoned cart emails are one of the highest-ROI automations in e-commerce. They routinely see 40–45% open rates and 10–15% click-through rates, far above typical marketing email benchmarks. The reason is simple: the customer already demonstrated purchase intent. They're warm leads, not cold ones.
Understanding why customers leave helps you write better recovery emails and, more importantly, fix the root causes.
Timing matters more than almost anything else in abandoned cart recovery. Send the first email too soon and it feels pushy. Wait too long and the customer has moved on. Research and industry practice point to a three-email sequence:
| Timing | Tone and content | |
|---|---|---|
| Email 1 | 1 hour after abandonment | Helpful reminder. "Did you forget something?" Show cart contents with images and a direct link back to checkout. No discounts yet. |
| Email 2 | 24 hours | Gentle nudge. Address common objections (free returns, customer support, reviews). Create mild urgency — "items in your cart aren't reserved." |
| Email 3 | 72 hours (3 days) | Final attempt with an incentive. 10% discount or free shipping. Make it clear this is the last reminder. |
The critical detail that many implementations miss: if the customer completes the purchase, cancel all pending emails immediately. Nothing erodes trust faster than receiving a "come back to your cart" email five minutes after you already bought the item.
Shopify, WooCommerce, BigCommerce, and most major platforms include abandoned cart email features out of the box.
Pros: Zero setup. Shopify's built-in recovery emails reportedly recover 3–5% of abandoned checkouts by default. It's free and works immediately.
Cons: Very limited customization. Typically only one email (not a sequence). No A/B testing. No conditional logic (e.g., different emails for first-time vs. returning customers). No integration with your broader marketing stack.
If you're on Shopify and doing less than $50K/month, this is a reasonable starting point. Beyond that, you'll want more control.
Platforms like Klaviyo, Omnisend, Drip, and Mailchimp offer sophisticated abandoned cart flows. They connect to your e-commerce platform, detect abandoned carts, and run multi-step email (and SMS) sequences with segmentation, A/B testing, and analytics.
Pros: Powerful features. Klaviyo's abandoned cart flows are considered best-in-class — they support branching logic, dynamic product blocks, personalized discount codes, and detailed revenue attribution.
Cons: Cost scales with contact list size. Klaviyo starts at $20/month for 500 contacts but can reach $1,000+/month for larger lists. You're also locked into their ecosystem for this workflow.
Build a periodic job that scans your database for abandoned carts and sends emails based on their age. This is the simplest custom approach.
# Run every 15 minutes via cron
# 0,15,30,45 * * * * python manage.py send_cart_reminders
from django.core.management.base import BaseCommand
from datetime import datetime, timedelta
from store.models import Cart
class Command(BaseCommand):
STAGES = [
{'min_age': timedelta(hours=1), 'max_age': timedelta(hours=2),
'email': 'cart_reminder_1'},
{'min_age': timedelta(hours=24), 'max_age': timedelta(hours=25),
'email': 'cart_reminder_2'},
{'min_age': timedelta(days=3), 'max_age': timedelta(days=3, hours=1),
'email': 'cart_reminder_3'},
]
def handle(self, **options):
now = datetime.utcnow()
for stage in self.STAGES:
carts = Cart.objects.filter(
status='abandoned',
updated_at__gte=now - stage['max_age'],
updated_at__lte=now - stage['min_age'],
emails_sent__lt=self.STAGES.index(stage) + 1,
purchased=False,
)
for cart in carts:
send_email(cart.user.email, stage['email'],
context={'cart': cart})
cart.emails_sent += 1
cart.save()Pros: Full control over logic and timing. No external service costs. Works with any email sending service (SES, Postmark, etc.).
Cons: Timing is approximate — emails go out when the cron job runs, not at the exact delay you want. A 15-minute cron interval means emails could be up to 15 minutes late. At scale, the database query scanning all abandoned carts every 15 minutes gets expensive. You also need to handle edge cases: what if the job takes longer than 15 minutes? What about duplicate sends?
Instead of polling, schedule a delayed job the moment a cart is created (or the moment you detect it's been abandoned). If the customer completes the purchase, cancel the pending jobs.
// Node.js with BullMQ example
import { Queue } from 'bullmq';
const cartQueue = new Queue('cart-recovery');
// When a cart is created or updated
async function onCartUpdated(cart) {
// Remove any existing scheduled jobs for this cart
const existingJobs = await cartQueue.getDelayed();
for (const job of existingJobs) {
if (job.data.cartId === cart.id) {
await job.remove();
}
}
if (cart.status === 'purchased') {
return; // Customer completed purchase
}
// Schedule the three-email sequence
const delays = [
{ name: 'reminder-1', delay: 60 * 60 * 1000 }, // 1 hour
{ name: 'reminder-2', delay: 24 * 60 * 60 * 1000 }, // 24 hours
{ name: 'reminder-3', delay: 3 * 24 * 60 * 60 * 1000 } // 3 days
];
for (const step of delays) {
await cartQueue.add(step.name, {
cartId: cart.id,
email: cart.userEmail,
step: step.name
}, { delay: step.delay });
}
}
// Worker processes the jobs
import { Worker } from 'bullmq';
const worker = new Worker('cart-recovery', async (job) => {
const cart = await Cart.findById(job.data.cartId);
// Critical: check if the cart was purchased since scheduling
if (cart.status === 'purchased') {
return; // Skip — customer already bought
}
await sendEmail(job.data.email, job.data.step, { cart });
});Pros: Precise timing for each cart. No database polling. The cancel-on-purchase pattern is clean. This is how most mature e-commerce backends handle it.
Cons: Requires running a Redis-backed queue (BullMQ, Sidekiq, Celery, etc.). Delayed jobs sitting in the queue for 3 days consume memory. Cancelling pending jobs requires scanning the delayed job set, which can be slow with many active carts. If Redis restarts without persistence, you lose all scheduled reminders.
An HTTP scheduler like Recuro offloads the "when to fire" problem to an external service. When a cart is created, you schedule HTTP callbacks at your desired intervals. The scheduler delivers webhooks to your server at the right times.
# When a cart is created, schedule the recovery sequence
# Email 1 — 1 hour later
curl -X POST https://api.recurohq.com/api/jobs \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{
"queue": "cart-recovery",
"url": "https://your-store.com/webhooks/cart-reminder",
"method": "POST",
"payload": {
"cart_id": "cart_8x92k",
"step": 1
},
"delay": 3600
}'
# Email 2 — 24 hours later
curl -X POST https://api.recurohq.com/api/jobs \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{
"queue": "cart-recovery",
"url": "https://your-store.com/webhooks/cart-reminder",
"method": "POST",
"payload": {
"cart_id": "cart_8x92k",
"step": 2
},
"delay": 86400
}'
# Email 3 — 72 hours later
curl -X POST https://api.recurohq.com/api/jobs \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{
"queue": "cart-recovery",
"url": "https://your-store.com/webhooks/cart-reminder",
"method": "POST",
"payload": {
"cart_id": "cart_8x92k",
"step": 3
},
"delay": 259200
}'Your webhook endpoint checks whether the cart was already purchased before sending the email. If the customer buys, you don't need to cancel the scheduled jobs — the endpoint simply returns early. (You can also cancel pending jobs via the API if you want to keep things clean.)
// Your webhook handler (any language/framework)
app.post('/webhooks/cart-reminder', async (req, res) => {
const { cart_id, step } = req.body;
const cart = await Cart.findById(cart_id);
if (!cart || cart.status === 'purchased') {
return res.status(200).json({ skipped: true });
}
const templates = {
1: 'cart-reminder-helpful',
2: 'cart-reminder-urgency',
3: 'cart-reminder-discount'
};
await sendEmail(cart.userEmail, templates[step], {
items: cart.items,
discountCode: step === 3 ? generateDiscount(cart) : null,
checkoutUrl: `https://your-store.com/checkout/${cart_id}`
});
return res.status(200).json({ sent: true });
});Pros: No queue infrastructure. Each cart gets independently timed callbacks. Works with any backend language. The scheduler handles durability and delivery guarantees.
Cons: External dependency. Requires your webhook endpoint to be idempotent and to verify the cart status before sending. Adds a small amount of latency vs. in-process job execution.
The single most important implementation detail in abandoned cart recovery is not sending emails after the customer has already purchased. This sounds obvious, but it's the most common failure mode.
There are two strategies:
The best implementations do both. Cancel proactively as a performance optimization (no wasted job processing), and check defensively as a safety net. Belt and suspenders.
Once your abandoned cart flow is running, the next step is optimizing it. Focus your A/B tests on the variables that actually move the needle:
Run one test at a time, wait for statistical significance, and implement the winner before moving to the next test. Resist the temptation to change multiple variables at once.
The best abandoned cart solution depends on where you are:
The most important thing is to have something in place. A basic abandoned cart email that goes out 1 hour after abandonment will recover more revenue than a perfect three-email sequence that never gets built.
Recuro handles scheduling, retries, alerts, and execution logs. 1,000 free requests to start.
No credit card required