The Weekly “What’s Stuck” Digest That Saves Your Biggest Shopify Deals

On most teams, Monday morning pipeline review is a vibe, not a process.

Your sales lead for enterprise Shopify stores opens HubSpot, Stripe, Notion, a couple of Slack DMs, and a Gmail search for "proposal"… then tries to answer one simple question:

Which accounts should I unstick this week?

Meanwhile, high-intent stores that installed your app, asked for a demo, or got a custom quote are quietly going cold. Nobody is "owning" them, not because you don’t care, but because nobody sees all the signals in one place at the right time.

The sequence at the top of this page is the whole journey, end to end. It exists to fix exactly that problem: a weekly, automated "what’s stuck" digest that lands in your internal inbox and surfaces every deal or account that has stalled past a threshold.

For a 5–10 person Shopify app team, this is the kind of automation that moves real money without adding a single headcount.

A quick story: CartWizard’s disappearing whales

CartWizard is a four-person team selling a cart recovery and AOV-boosting app on the Shopify App Store. They’re at $95k MRR, with most revenue coming from $49/mo self-serve plans. But their upside lives in bigger stores paying $299–$999/mo for custom support.

Those bigger stores don’t behave like self-serve:

• They install the app, then book a demo.

• There’s a custom discount or a feature question.

• Sometimes procurement gets involved.

Deals stretch across weeks, with a mix of in-app events (app_installed, feature_used), email replies, and human conversations. What CartWizard’s founder kept seeing in Stripe and the app store reports:

• Big brands trial the app.

• They "go dark" for a couple of weeks.

• By the time someone checks on them, they’ve uninstalled or picked a competitor.

No one on the team woke up thinking "let’s ignore the $800/mo opportunity." It died because they didn’t have a system that yelled, "Hey, this account hasn’t moved in 14 days."

That’s what this journey does. It turns a fuzzy pipeline feeling into a predictable, weekly list of exactly who is stuck and who owns them.

What this automation actually does

At a high level, the journey does three things:

1. Once a week, it asks: "Who looks stalled?"

2. For each stalled contact, it sends an internal email with everything a human needs to unblock them.

3. It tags and timestamps those contacts so you can measure whether the team is getting better at turning "stuck" into "closed."

Under the hood, it uses:

• A Cyclic trigger to run on a weekly schedule.

• The segment builder to define "stuck."

• Send Internal Email to deliver the digest item into a shared inbox.

• Add Tag and Update Contact Attribute to track that the alert was sent.

You configure this once in the journey editor, using the same canvas you’d use to build a journey for customer-facing automation. Then it just runs.

Let’s walk through the nodes.

Node 1: A Cyclic trigger that behaves like a weekly watchdog

Start with a Cyclic trigger. This is the heartbeat of the pattern.

Configuration:

• Repeat interval: every 1 week

• Day and time: Monday at 08:30 (pick whatever time makes sense for your sales or success standup)

• Timezone: your team’s working timezone

• Re-enrollment: on

Re-enrollment matters. With it on, the same account can be processed every Monday as long as it still looks stuck. Without it, each contact would only ever appear once, which defeats the point of a recurring review.

The interesting part is the criteria on the Cyclic trigger. This is where the segment builder earns its keep.

For CartWizard’s enterprise pipeline, they defined "stuck" as:

• Contact is tagged with stage-demo-done or stage-proposal-sent.

• Custom event contract_signed has not triggered over all time.

• Custom event deal_progressed has not triggered in the last 14 days.

• Email subscription status is not Unsubscribed (you still want to talk to them).

In plain English: "Deals we’ve progressed past the intro, haven’t won yet, and haven’t moved in at least two weeks."

You can express that exactly in the criteria builder:

• Tag rules using "contact is tagged with".

• Custom event rules using "has not triggered in the last 14 days".

• Subscription status with a simple "is not."

If you’re tracking pipeline events from your app or backend via the Spreeflo API, this is just wiring those events (demo_booked, proposal_sent, contract_signed) into custom events and then filtering on them.

The result: every Monday at 08:30, Spreeflo pulls a fresh list of contacts who currently match that stalled definition and pushes each one into the rest of the journey.

Node 2: A Multi-way Split for “which stuck accounts matter most?”

Not every stalled Shopify store deserves the same level of panic.

After the Cyclic trigger, the sequence at the top of this page routes contacts into a Multi-way Split that separates:

• High-value enterprise opportunities

• Mid-tier stores you still care about

• Everyone else (optional)

You might use a numeric contact attribute like estimated_mrr or plan_target for this. CartWizard tracks est_monthly_value per opportunity based on store size and previous conversations.

Example split:

• Branch "High value": est_monthly_value greater than 500

• Branch "Mid value": est_monthly_value greater than 100

• Else: everything below that

Each branch uses the segment builder again, this time looking at a number field with operators like "greater than."

Why split here instead of sending one generic email for everyone?

Because your founder or head of sales only has so much time. Giving them a short, focused list of the 5 highest-value stuck accounts is better than a noisy list of 40. The Multi-way Split keeps the canvas tidy while letting you tune messaging (and recipients) by deal size.

Node 3: Send Internal Email – the actual “what’s stuck” digest item

From each Multi-way branch, the next node is Send Internal Email.

Think of this as a single line item in the digest for one contact. On Monday morning, your "sales@" or "success@" inbox will receive one email per stuck account, which most inboxes collapse into a neat conversation thread.

For the high-value branch, CartWizard’s internal email template looks something like this:

• Subject: STUCK: {{ contact.company_name }} – {{ contact.est_monthly_value }} MRR potential

• Body:

• Who the store is (company name, Shopify URL)

• Which stage they’re in (stage-demo-done vs stage-proposal-sent)

• When the last "progress" event occurred

• Who owns the deal internally (e.g., owner_email)

• A link back to their CRM record or internal doc

• A short checklist: "Call?", "Send pricing tweak?", "Ask for decision?"

You build this inside the same email builder you’d use for customer-facing messages, but the recipient is your team. The template can pull in any contact attributes or event-derived fields you’ve synced.

Why Send Internal Email instead of yet another report in a BI tool?

Because people actually live in their inbox. A simple, well-structured email is harder to ignore than:

• A dashboard link nobody opens

• A spreadsheet that goes stale

• A manual status meeting that gets bumped every busy week

By pushing context into a channel that already has your team’s attention, you reduce friction between "seeing that a deal is stuck" and "doing something about it."

For the mid-value branch, you might send a slightly different email, or the same one but to a different shared inbox used by a customer success manager.

Node 4: Tag stuck accounts when you’ve emailed the team

After each Send Internal Email node, add an Add Tag action. For example:

• Tag: stuck-digest-sent

This might seem redundant. The team already got the email, why also tag the contact?

Two reasons:

1. It gives you a quick segment for diagnostics: "How many accounts are we regularly seeing as stuck?"

2. It helps prevent edge cases if you later add more automation based on the same data.

Because Add Tag has a "Force tag trigger" option, you can decide whether applying the tag again should fire any downstream "Added Tag" journeys. In this pattern, you’d usually leave "Force tag trigger" off. The tag is just a marker, not a trigger for additional messaging.

You can later build a segment like "contacts tagged with stuck-digest-sent that are still in a stuck stage" to find chronic problem accounts.

Node 5: Timestamp each alert so you can measure improvement

Finally, add an Update Contact Attribute node to write when this alert was last sent.

You might create a custom timestamp attribute like last_stuck_digest_at and configure the node to:

• Attribute: last_stuck_digest_at

• Update type: SET_NOW

This uses the timestamp’s "Set to now" update type, which writes the exact time the node executes.

That single field lets you:

• Calculate "time-to-unblock" by comparing it to the time the account leaves your "stuck" criteria.

• Answer questions like "How many weeks in a row has this store shown up in the digest?"

You could even use that attribute in another journey: for example, a Criteria Match trigger that alerts the founder if an account has been in the stuck digest three weeks in a row.

Adapting the pattern beyond classic “deals”

The same weekly Cyclic + Internal Email spine works for more than just enterprise opportunities.

For a Shopify or e‑commerce app, other high-leverage versions are:

1. Stalled high-value trials
   Criteria:
   - App installed
   - On a trial or free plan
   - Has not triggered your core feature_used event in the last 10 days
   - Estimated value above a threshold
   
   The internal email goes to product or customer success with a prompt like "Offer white-glove onboarding" or "Record a quick Loom for this store."

2. At-risk large customers
   Criteria:
   - On your highest paid tier
   - Custom event feature_used has not triggered in the last 21 days
   - Or repeated payment_failed events
   
   The email prompts a human to step in before churn. You can support this with app-side activity tracked through web tracking and analytics if your app has a web dashboard.

3. Partnerships that went quiet
   Criteria:
   - Tagged as partner-lead or integration-opportunity
   - Custom event partner_meeting happened once
   - No follow-up events in the last 30 days
   
   The digest delivers a gentle reminder for your BD lead to nudge them.

All of these use the same skeleton: Cyclic trigger → criteria definition → internal email → simple tracking tags and timestamps. You just swap out which signals define "stuck."

Making the data side sane for a small team

This pattern works only as well as the data you feed it. For a lean app team, that means:

• Decide which 3–5 lifecycle events truly matter (demo_booked, proposal_sent, contract_signed, core_feature_used, payment_failed).

• Send them into Spreeflo with Spreeflo.track from the SDK in your frontend or via the Spreeflo API.

• Keep a small set of contact attributes current: plan, est_monthly_value, owner_email, deal_stage.

You don’t need a full CRM replication. Just enough detail per contact so the segment builder can pick out who’s stuck, and the internal email has enough context for a human to act.

This is where the second core belief of the product shows up clearly: founder-led businesses win on leverage, not headcount. You could hire an SDR to chase these accounts manually. Or you can spend an afternoon wiring a few key events into Spreeflo and let this journey hand you a prioritized list every Monday for the next three years.

How to know if your “what’s stuck” digest is working

Two simple metrics tell you if this automation earns its keep:

1. Time-to-unblock
   How many days pass between a contact first appearing as "stuck" and either:
   - Converting (trial → paid, opportunity → closed-won), or
   - Closing out (they uninstall, say no, or clearly churn).
   
   You can approximate this by comparing last_stuck_digest_at to the timestamp of contract_signed, plan_upgraded, or app_uninstalled events.

2. Stuck-deal resolution rate
   Of the accounts that appear in the digest in a given week, what percent are no longer "stuck" by the time the next digest runs?
   
   This can be as simple as:
   - Build a segment "Stuck this week."
   - Build another segment "Still stuck after 7 days."
   - Compare counts.

You don’t need a fancy chart for this to be useful. Even watching those numbers in a monthly review tells you whether the combination of the digest plus human follow-through is improving.

If CartWizard sees resolution rate rise from 20% to 45% over a couple of months, that’s a material lift in MRR from a couple of nodes in a journey.

The bigger payoff: a founder who doesn’t have to babysit the pipeline

The obvious win of this pattern is fewer large Shopify stores slipping through the cracks. The less obvious win is how much cognitive load it takes off the founder or Head of Sales.

Instead of:

• Remembering to pull a report

• Cleaning it up in a spreadsheet

• Slacking it to the team

• Chasing follow-ups manually

You have a journey that:

• Runs on a fixed cadence,

• Uses the same contact data that powers your other automations,

• Shows up where your team already lives (their inbox).

It’s a small example of what good marketing automation is supposed to do for founder-led companies: build the system once, let it compound every week while you focus on shipping the next feature, improving your app store listing, or talking to users.

If you’re already using Spreeflo for campaigns or onboarding flows, this is one of the simplest high-ROI internal journeys you can add. Open the journey editor, drop in a Cyclic trigger, wire it through a couple of process and action nodes, and give your future self a Monday morning where the question "What’s stuck?" is answered before the coffee finishes brewing.