Price Rules Engine

Price Rules Engine

Overview

A price rules engine lets you define multiple concurrent promotions — site-wide sales, coupon codes, loyalty discounts — and apply them to a cart in a predictable, controlled order. The key concerns are: which rules apply to which products, which rules can stack with others, and what happens when multiple rules target the same item. Every major platform has some form of this built in; the gap is usually in advanced stacking control and customer-segment targeting.

When to Use This Skill

• When you have multiple concurrent promotions (site-wide sale + coupon + loyalty discount) and need deterministic stacking behavior
• When marketing needs to create complex promotions (e.g., "20% off all shoes except Nike, for Gold loyalty members") without engineering involvement
• When migrating from hardcoded promotional logic scattered across the codebase to a data-driven rule system
• When building a promotion scheduler that activates and deactivates rules at configured times
• When you need an audit log that shows exactly which rules were applied and why for customer service queries

Core Instructions

Step 1: Determine the merchant's platform and choose the right tool

Step 2: Configure price rules with stacking on your platform

---

Shopify

Shopify manages discount stacking through the Combinations setting on each discount.

Setting up stacking rules: 1. Go to Discounts → create or edit a discount 2. Scroll to the Combinations section 3. Toggle which types this discount can combine with:

• Product discounts — can this stack with other product-level discounts?
• Order discounts — can this stack with order-level discounts?
• Shipping discounts — can this stack with free-shipping discounts?

4. For automatic discounts, the highest-value automatic discount takes precedence by default; use Combinations to allow stacking

Customer-segment targeting: 1. Under Customer eligibility, choose Specific customer segments 2. Select segments created in Customers → Segments (e.g., "VIP customers", "First-time buyers")

Priority and exclusions:

• Set Start and end dates to control which rules are active
• Under Products, set which products or collections the discount applies to
• Add exclusions: "Exclude sale items" or specify products that are excluded

Shopify Plus — Shopify Scripts: For rules that cannot be expressed through the Discounts UI (e.g., tiered stacking where the second discount only applies if the cart is above a threshold): 1. Go to Apps → Script Editor (Scripts is a separate Shopify Plus feature) 2. Create a Line Item Script or Shipping Script 3. Scripts run at checkout and can apply complex conditional discounts; they take precedence over other discounts

Bold Discounts (App Store, ~$20/month): A visual rule builder for Shopify that supports:

• Stack / don't stack per promotion
• Priority ordering between promotions
• Complex conditions (customer tags, collection membership, quantity thresholds)

---

WooCommerce

WooCommerce coupons support basic single-rule discounts. For a full price rules engine with priority ordering and stacking control, use the Dynamic Pricing plugin.

Installing and configuring YITH WooCommerce Dynamic Pricing & Discounts: 1. Install the plugin from YITH.com (~$70/year) 2. Go to YITH → Dynamic Pricing → Pricing Rules 3. Create a rule and configure:

• Type: cart, product, or category pricing
• Discount: percentage or fixed amount
• Conditions: cart subtotal, quantity, customer role, date range
• Products/categories: which items the rule applies to; set exclusions
• Priority: lower number = higher priority (applied first)
• Stacking: "Stop other rules" to prevent lower-priority rules from stacking

Customer segment targeting in WooCommerce: 1. Use WooCommerce Customer Roles (available via plugins like User Role Editor or WooCommerce B2B):

• Assign customers to roles like "wholesale", "vip", "trade"

2. In Dynamic Pricing rules, restrict each rule to specific customer roles 3. Customers in that role see the discounted price; others see the regular price

Example: VIP-only 20% off apparel, excludes clearance: 1. Create a rule: Type = Category pricing, Category = Apparel 2. Discount = 20% off 3. Customer Role = VIP 4. Excluded products: [list of clearance product IDs] 5. Priority = 10

---

BigCommerce

BigCommerce's Promotions engine natively supports priority ordering and stacking control.

1. Go to Marketing → Promotions → Create Promotion 2. Under Conditions:

• Set cart value, quantity, or product conditions
• Under Customer groups: restrict to specific groups (wholesale, VIP, etc.)

3. Under Actions: set the discount type and amount 4. Set Shipping conditions if applicable 5. Under Rules:

• Can be combined with other promotions: yes/no
• Priority: lower number runs first

6. Set Active date range

BigCommerce evaluates promotions in priority order and respects the "can be combined" setting. Multiple non-combinable promotions will apply only the best-value one for the customer.

---

Custom / Headless

For custom storefronts, implement a rule evaluator that processes rules in priority order, enforces stacking constraints, and applies rules to eligible cart lines:

interface PriceRule {
  id: string;
  name: string;
  type: 'percentage_off' | 'fixed_off' | 'free_shipping' | 'buy_x_get_y';
  value: number;            // percentage or cents
  priority: number;         // higher = applied first
  isStackable: boolean;
  couponCode?: string;      // null = automatic (no code required)
  minCartCents?: number;
  customerSegments?: string[];
  applicableProducts?: string[];
  applicableCategories?: string[];
  excludedProducts?: string[];
  startsAt: Date;
  endsAt?: Date;
}

interface CartContext {
  lines: { lineId: string; productId: string; categoryIds: string[]; quantity: number; currentPriceCents: number }[];
  subtotalCents: number;
  customerSegments: string[];
  appliedCouponCode?: string;
}

function evaluateRules(cart: CartContext, rules: PriceRule[]): { ruleId: string; discountCents: number }[] {
  const now = new Date();
  const active = rules.filter(r =>
    r.startsAt <= now && (!r.endsAt || r.endsAt > now)
  ).sort((a, b) => b.priority - a.priority); // highest priority first

  const applications: { ruleId: string; discountCents: number }[] = [];
  let nonStackableApplied = false;

  for (const rule of active) {
    if (!rule.isStackable && nonStackableApplied) continue;

    // Coupon-linked rules require the code to be applied
    if (rule.couponCode && rule.couponCode !== cart.appliedCouponCode) continue;

    // Cart minimum check
    if (rule.minCartCents && cart.subtotalCents < rule.minCartCents) continue;

    // Customer segment check
    if (rule.customerSegments?.length && !rule.customerSegments.some(s => cart.customerSegments.includes(s))) continue;

    // Find eligible lines
    const eligibleLines = cart.lines.filter(line => {
      if (rule.excludedProducts?.includes(line.productId)) return false;
      if (rule.applicableProducts?.length) return rule.applicableProducts.includes(line.productId);
      if (rule.applicableCategories?.length) return rule.applicableCategories.some(c => line.categoryIds.includes(c));
      return true; // no scope restriction = all products
    });
    if (eligibleLines.length === 0) continue;

    let discountCents = 0;
    if (rule.type === 'percentage_off') {
      discountCents = Math.round(
        eligibleLines.reduce((s, l) => s + l.currentPriceCents * l.quantity, 0) * rule.value / 100
      );
    } else if (rule.type === 'fixed_off') {
      discountCents = Math.min(rule.value, cart.subtotalCents);
    }

    if (discountCents > 0) {
      applications.push({ ruleId: rule.id, discountCents });
      if (!rule.isStackable) nonStackableApplied = true;
    }
  }

  return applications;
}

Persist rule applications with every order so you can answer customer service questions ("which discount applied?") and track promotion ROI.

Best Practices

• Higher priority = evaluated first — use an explicit priority integer so marketing can control evaluation order without code changes
• Separate stackable from exclusive rules — once a non-stackable rule applies, skip all subsequent non-stackable rules; stackable rules always apply on top
• Test rules in "dry run" mode before activating — review the discount calculation on a sample cart before the promotion goes live
• Use exclusion lists generously — always allow marketing to specify excluded products/categories; unexpected application to premium or already-reduced items creates margin problems
• Version rules rather than editing live rules — deactivate old rules and create new versions; this preserves historical calculation for past orders
• Log which rules were applied to each order — store rule IDs and discount amounts on the order for customer service and ROI analysis

Common Pitfalls

Related Skills

• @coupon-management
• @discount-engine
• @dynamic-pricing
• @ab-testing-pricing
• @volume-pricing

Promotion Tracking and Safe Rule Updates

Problem/Feature Description

GearUp, a sporting goods retailer, has been running a pricing rule engine for two months and has surfaced two critical problems. First, customer service agents cannot look up exactly which promotions were applied to a specific past order — they only see the final discounted total, making refund calculations and dispute resolution very difficult. The team needs a function that, when an order is placed, records every applied discount against the order for future auditing.

Second, there are correctness questions about the "Accessories Buy 2 Get 1 Free" promotion: customers have been complaining the wrong item is being made free, and the engineering team needs to revisit that calculation. On top of that, the CMO wants to change the minimum cart value on their site-wide "Summer Flat $15 Off" promotion from $75 to $100 because margins are being squeezed — the team needs a workflow that changes the rule without corrupting the audit trail for the 3,400 orders already placed under the old terms.

Your task is to address all three gaps: 1. Implement the order-placement logic that persists discount records 2. Implement correct discount calculations for the flat-off and buy-X-get-Y rule types 3. Demonstrate a safe workflow for updating the live Summer sale rule

Output Specification

Produce a solution/ directory containing:

• persist.ts (or .js) — the function that records rule applications when an order is placed
• apply-rules.ts (or .js) — implementations of the fixed_off and buy_x_get_y discount calculations
• rule-update.ts (or .js) — a script or function demonstrating how to safely update the live Summer sale rule
• tests/ — test files providing good coverage of the persistence, discount calculation, and rule update logic
• A README.md explaining the design decisions

Input Files

The following rules and orders are provided as starting context. Extract them before beginning.

=============== FILE: inputs/existing-rules.json =============== { "rules": [ { "id": "rule-b2g1-accessories", "name": "Accessories Buy 2 Get 1 Free", "type": "buy_x_get_y", "value": null, "priority": 20, "is_stackable": true, "applicable_categories": ["cat-accessories"], "is_active": true, "usage_limit": null, "usage_count": 847 }, { "id": "rule-summer-flat15", "name": "Summer Flat $15 Off", "type": "fixed_off", "value": 1500, "priority": 10, "is_stackable": false, "min_cart_value": 7500, "is_active": true, "usage_limit": 5000, "usage_count": 3400 } ] }

Checkout Promotions Evaluator

Problem/Feature Description

Trendy Threads is a mid-size online fashion retailer that runs several promotions at any given time: a site-wide seasonal sale, a loyalty members-only discount, and periodic flash coupon codes distributed via email. Until now each of these was a separate if-statement scattered across the checkout service, which made it impossible to predict or debug which discounts would fire for a given cart.

The engineering team wants a single TypeScript function, evaluateRules, that accepts a cart context and a list of active promotion rules, and returns an array of applied promotion results. The function must handle the full complexity of concurrent promotions: conflicting exclusive deals, coupon-code-gated offers, rules that have run their course, time-limited campaigns, and the need to layer additional discounts on top of an already-reduced price. Marketing has also asked for a way to preview what discounts would apply to a cart without actually recording anything, so they can test new rules before launching.

Output Specification

Implement the evaluateRules function in TypeScript (or JavaScript). Produce a solution/ directory containing:

• evaluator.ts (or .js) — the core evaluation function with full inline comments explaining key decisions
• evaluator.test.ts (or .test.js) — test cases that achieve good coverage of the evaluation logic across a variety of cart and rule configurations
• A README.md briefly describing the approach and any notable design choices

All monetary values in the tests should be expressed as integers (e.g. a $29.99 item should appear as 2999).

Promotions Infrastructure for a Fashion Retailer

Problem/Feature Description

StyleHub is a fashion e-commerce platform preparing for their biggest promotional calendar of the year: a summer sale that applies to all apparel except their new premium collection, a loyalty-tier discount exclusively for "Gold" and "Platinum" members, a site-wide free-shipping threshold for any order over a certain value, and category-specific deals on accessories with no customer restrictions.

The backend team has been asked to create the database schema and the eligibility filtering logic that determines which cart lines a given rule applies to. The marketing team is particularly anxious about two past incidents: a premium capsule collection accidentally got discounted during last year's sale, and a loyalty reward once applied to a guest checkout. The schema must make it straightforward to prevent both issues. Marketing also wants the flexibility to create rules that apply automatically (no code required) as well as rules gated behind a coupon code.

Output Specification

Produce a solution/ directory containing:

• schema.sql — DDL statements creating the price rules table (and any supporting tables needed for auditing applied discounts)
• eligibility.ts (or .js) — a getEligibleLines function (and any helpers) that filters a list of cart lines based on a rule's inclusion/exclusion configuration
• eligibility.test.ts (or .test.js) — test cases covering a variety of rule configurations and cart compositions drawn from the sample data below, including targeting edge cases
• A brief README.md describing design decisions

Input Files

The following sample data can be used as fixtures in your tests. Extract them before beginning.

=============== FILE: inputs/sample-categories.json =============== { "categories": [ { "id": "cat-apparel", "name": "Apparel" }, { "id": "cat-accessories", "name": "Accessories" }, { "id": "cat-premium", "name": "Premium Collection" } ], "products": [ { "id": "prod-shirt-001", "name": "Classic T-Shirt", "categoryIds": ["cat-apparel"] }, { "id": "prod-premium-jacket", "name": "Designer Jacket", "categoryIds": ["cat-apparel", "cat-premium"] }, { "id": "prod-belt-001", "name": "Leather Belt", "categoryIds": ["cat-accessories"] } ] }