PayLogic V1.3 shipped — feature-complete for the June 30 Shopify Scripts deadline

Shopify Scripts — the Ruby-based payment customization tool that’s been around for ~8 years on Shopify Plus — shuts off June 30, 2026. Editing’s already disabled since April. Come June 30, any active payment Script silently stops firing and merchant checkouts revert to default.

Estimates put 2,000–5,000 Plus merchants on Scripts for payment customization specifically. Each one has a hard migration deadline. I built PayLogic for that.

V1.3 just shipped and the product is feature-complete for the deadline. Here’s the full picture: every feature, what tier it’s on, and the reasoning behind the pricing.

Current state

The feature tour

Conditions (when does a rule fire?)

PayLogic ships 16 rule templates. The conditions you can build rules around:

• Cart total ≥ or ≤ a threshold
• Item count threshold
• Shipping country (one or many)
• Cart currency (one or many)
• Shipping method title contains a keyword
• First-time customer (no prior orders)
• Returning customer (≥ N prior orders)
• Early customer (≤ N prior orders)
• Big spender (lifetime amount-spent threshold)
• Customer has any of these tags
• Customer is missing all of these tags
• Product in cart has any of these tags
• Risk composite (heuristic combining first-time + cart total + flagged shipping countries — fully merchant-configurable)
• Customer prior risk (uses Shopify’s order risk model — more on this below)

Actions (what does the rule do?)

• Hide a payment method at checkout
• Rename a payment method (“Cash on Delivery” → “Pay at door — $5 handling fee”)
• Reorder payment methods (move Shop Pay to position 1 for repeat customers, etc.)

Plus

• Multi-condition rules with AND/OR logic
• One-click Shopify Scripts importer — reads your existing Ruby, converts the common patterns to PayLogic rules
• Checkout UI extension that displays a merchant-authored message when a method is hidden (“Cash on Delivery isn’t available for orders over $200”)
• Auto tag-cache backfill on install (so tag rules work immediately, no manual setup)
• Rule versioning with one-click rollback (last 50 snapshots, Plus tier only)

Tier breakdown

The differentiator that earns the Plus upgrade

The customer prior-risk rule exposes Shopify’s native order risk signal: “hide Cash on Delivery for customers whose past orders Shopify flagged HIGH or MEDIUM risk.”

Scripts couldn’t see this data. Functions can. For COD-heavy markets (MENA, SEA, LATAM) where return-to-origin rates sit at 25–35%, this single rule typically cuts RTO 5–15 percentage points. On a store doing $50k/mo of COD volume, that’s $7–9k/year of recovered freight. The app pays for itself in roughly a week.

This is the rule that exists because the platform changed.

Why $1.99 when competitors charge $9–25

Most apps in the Shopify payment customization space price at $9–$25/mo with no free tier. I priced PayLogic far below that on purpose.

The math: most payment Scripts in production do $1–50/month of value for the merchant — they stop the occasional bad order, not transform the business. If the app costs $20/mo, the value gap is thin and most merchants churn within a month.

I’d rather be the obvious “yes” pick at the entry tier and earn the upgrade to $9.99 Plus via the risk rule. The Free Dev plan is bait for agencies who’d otherwise have to budget the app on every client install.

Am I leaving money on the table? Maybe. I’ll know once I have ~50 paid installs to look at the conversion mix.

The bug that ate my Friday

V1.3 (the custom-tag rules) shipped Thursday. I tested it on the dev store. Cash on Delivery wouldn’t hide for the tagged customer. Spent ~8 hours debugging this.

Surface symptom: the rule’s condition (customer_has_any_tag: ["myopia-tier-2"]) evaluated to false even though the customer clearly had the tag in Shopify admin.

The actual cause was a 4-layer onion:

1. The Function reads tags from a metafield (paylogic.tags-cache), not the live tag field. We cache via webhook.
2. The customers/update webhook payload contains a tags field. I trusted it.
3. Shopify redacts PCD-gated fields in webhook payloads independently of Admin API access. The tags field is redacted even when PCD Level 1 is approved. So payload.tags was always empty.
4. The handler wrote {"tags":[]} to the cache every time. Worse: every metafield write itself fires a customers/update webhook → which writes empty again → permanent feedback loop.

Fix: ignore payload.tags entirely. Use the customer ID from the payload to query Admin GraphQL for the real tags. The Admin API respects PCD properly (returns real tags when granted, errors when not).

If you’re building a Shopify app that touches PCD fields, you almost certainly need to know this.

Architecture (for the curious)

• Built on Shopify Functions (Rust → WASM), runs at Shopify’s edge with sub-50ms p95 latency
• No carrier-service callback hacks — fully Functions-native
• Webhook-cached tag system: the Function reads tags from a metafield kept fresh by customers/update and products/update webhook handlers (so tag-based rules match against any tag with no scope or latency penalties)
• Rule config stored in payment customization metafields; full version history kept in Prisma on the app backend
• Free Scripts → Rules converter on paylogic.dev runs the same parser as the in-app importer, so what merchants see in the converter is exactly what they’d get on install

What’s next

The product is done for V1. Bottleneck now is distribution, not features.

• Product Hunt launch in ~10 days (the converter tool is the marquee asset)
• Cold email to 50–100 Scripts-using Plus merchants sourced via BuiltWith
• This post (cross-posted on DEV.to)
• Long-form blog content for SEO (already 2 posts up: Scripts migration guide and 5 ways to hide Cash on Delivery compared)

13-month window until the deadline. The product is ready; distribution is the actual job for the next year.

If you’re on Shopify Plus and use Scripts, the free converter at paylogic.dev/scripts-converter/ might save you 10 minutes. Genuinely useful feedback if it misses patterns your scripts use.

If you’re building a Shopify app or pricing indie SaaS, happy to swap notes — pricing strategy, Shopify Functions, distribution tactics, all of it.