Dynamic Pricing

Dynamic Pricing

Overview

Dynamic pricing automatically adjusts product prices based on demand signals, inventory levels, competitor prices, and business rules. The goal is to maximize revenue per unit sold — raising prices when demand is strong or inventory is scarce, and reducing them to clear slow-moving stock. Most Shopify and WooCommerce merchants accomplish this with a repricing app rather than custom code. Custom implementations are reserved for headless storefronts or merchants with unique repricing logic that apps cannot handle.

When to Use This Skill

• When high-velocity SKUs lose revenue because prices are set-and-forgotten while competitors adjust hourly
• When you need to liquidate slow-moving inventory through automatic markdown schedules
• When running a marketplace where seller prices must respond to competitive pressure
• When building a revenue management system for perishable or time-sensitive inventory
• When A/B testing price elasticity at scale and needing a framework to safely roll out price changes

Core Instructions

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

Step 2: Define your pricing rules before configuring any tool

Before touching any tool, document your guardrails — these prevent the repricing algorithm from making decisions that destroy margin or customer trust:

Step 3: Platform-specific setup

---

Shopify

Option A: Prisync (competitor-based repricing)

1. Sign up at prisync.com and connect your Shopify store via the integration 2. Add competitor product URLs to track in the Prisync dashboard 3. Set repricing rules: "Match lowest competitor price", "Beat by X%", or "Match and beat" 4. Set your floor and ceiling prices per product 5. Prisync pushes price updates to Shopify automatically on your configured schedule (hourly, daily)

Option B: Shopify Flow (inventory/demand-based, Shopify Plus)

1. In your Shopify admin, go to Apps → Flow 2. Create a new workflow triggered by Inventory level changed or a custom webhook 3. Add a condition: e.g., "Inventory quantity is less than 10" 4. Add an action: Update product variant and set the price to a higher value 5. Add a separate workflow for when inventory recovers to restore the original price

Keep the original prices stored as a product metafield (product.metafields.pricing.original_price) so you can always restore them.

Option C: Third-party apps for demand-based repricing

• Wiser (Shopify App Store): uses sales velocity, add-to-cart rates, and inventory to suggest and apply price changes
• Bold Commerce's Pricing: allows scheduling price changes and automated rules

---

WooCommerce

Option A: Prisync + WooCommerce REST API

1. Connect Prisync to WooCommerce using the REST API credentials (WooCommerce Settings → Advanced → REST API → Add key) 2. Map your products in Prisync to competitor URLs 3. Configure repricing rules and schedules in Prisync 4. Prisync calls PUT /wp-json/wc/v3/products/{id}/variations/{id} to update prices

Option B: Custom scheduled repricing via WP-Cron

For demand-based repricing in WooCommerce, use a scheduled task: 1. Write a PHP function that checks inventory levels and sales velocity via WooCommerce's order history 2. Schedule it with WP-Cron or a server cron 3. Call wc_get_product()->set_price() and save() to update prices programmatically 4. Log every price change to a custom table for audit and rollback

Option C: YITH Dynamic Pricing plugin

For time-based price changes (scheduled markdowns): 1. Install YITH WooCommerce Dynamic Pricing & Discounts 2. Create rules that apply a percentage discount during specific date ranges 3. This is simpler than full dynamic repricing but covers "end of season" markdown use cases

---

BigCommerce

BigCommerce's Price Lists feature is ideal for dynamic customer-segment pricing:

1. Go to Products → Price Lists 2. Create price lists per customer group (e.g., "demand_high_inventory_low") 3. Use the BigCommerce Price Lists API to update prices programmatically based on your pricing logic 4. Assign price lists to customer groups via Customers → Customer Groups

For site-wide dynamic pricing without customer segmentation, use the BigCommerce Catalog API to update sale_price on products based on your repricing schedule.

Third-party tools: Linnworks and ChannelAdvisor both integrate with BigCommerce and include competitor monitoring and automated repricing.

---

Custom / Headless

For headless storefronts, implement a repricing job that runs on a schedule:

import { CronJob } from 'cron';

interface PricingContext {
  productId: string;
  currentPriceCents: number;
  costCents: number;
  inventoryLevel: number;
  salesVelocity7d: number;       // units/day rolling average
  competitorLowestCents?: number; // from price intelligence feed
  floorCents: number;
  ceilingCents: number;
}

function computeNewPrice(ctx: PricingContext): { priceCents: number; reason: string } {
  let price = ctx.currentPriceCents;
  const reasons: string[] = [];

  // Inventory pressure: near stockout → slow demand with a price increase
  if (ctx.inventoryLevel <= 5 && ctx.salesVelocity7d > 0.5) {
    price = Math.round(price * 1.08);
    reasons.push('low_inventory');
  }

  // Slow mover: markdown if no meaningful sales in 7 days
  if (ctx.salesVelocity7d < 0.1) {
    price = Math.round(price * 0.95);
    reasons.push('slow_mover_markdown');
  }

  // Competitor pricing: stay competitive
  if (ctx.competitorLowestCents && price > ctx.competitorLowestCents * 1.05) {
    price = Math.round(ctx.competitorLowestCents * 0.99); // undercut by 1%
    reasons.push('competitor_undercut');
  }

  // Enforce guardrails
  const marginFloor = Math.round(ctx.costCents * 1.15);
  price = Math.max(price, marginFloor, ctx.floorCents);
  price = Math.min(price, ctx.ceilingCents);

  // Only apply if change exceeds 2% threshold
  const changePct = Math.abs(price - ctx.currentPriceCents) / ctx.currentPriceCents;
  if (changePct < 0.02) return { priceCents: ctx.currentPriceCents, reason: 'below_threshold' };

  // Cap single-run change at 20%
  if (changePct > 0.20) {
    const direction = price > ctx.currentPriceCents ? 1 : -1;
    price = Math.round(ctx.currentPriceCents * (1 + direction * 0.20));
    reasons.push('capped_at_20pct');
  }

  return { priceCents: price, reason: reasons.join(',') || 'no_change' };
}

// Run every 30 minutes during business hours
new CronJob('*/30 6-22 * * *', async () => {
  const products = await db.products.findAll({ dynamicPricingEnabled: true });
  for (const product of products) {
    const ctx = await buildPricingContext(product);
    const { priceCents, reason } = computeNewPrice(ctx);
    if (priceCents !== ctx.currentPriceCents) {
      await platformApi.updatePrice(product.id, priceCents);
      await db.priceHistory.insert({ productId: product.id, oldPrice: ctx.currentPriceCents, newPrice: priceCents, reason, changedAt: new Date() });
    }
  }
}, null, true, 'America/New_York');

Best Practices

• Always enforce a floor price tied to cost — compute floor = cost × 1 + min_margin and make it inviolable; no algorithm override permitted below cost
• Store a full price history — every price change needs a row with timestamp, old price, new price, and reason for rollback, audits, and elasticity analysis
• Cap single-run price changes — limit any single job run to ±20% to prevent runaway repricing from bad data or bugs
• Separate recommendation from application — the engine proposes a price; a separate step applies it; this enables human review queues and dry-run mode
• Alert on large automatic changes — send a Slack or email alert when the engine applies a change greater than 10% so a human can review
• A/B test price changes — before rolling out a new price site-wide, run a test on a segment of visitors using the A/B testing pricing skill

Common Pitfalls

Related Skills

• @ab-testing-pricing
• @flash-sale-engine
• @price-rules-engine
• @volume-pricing
• @discount-engine

Competitor Price Monitor and Price Audit Trail

Problem/Feature Description

PriceWatch is a B2B SaaS product that helps online retailers track competitor prices and maintain a complete audit trail of every price change for regulatory compliance. A new client in the EU needs two things: (1) a module that can scrape live prices from competitor product pages given a CSS selector and URL, discarding any data older than a certain freshness threshold; and (2) a PostgreSQL schema and corresponding data-access layer that records every price change with enough detail to support rollback, compliance audits, and volatility analytics. The scheduler should run frequently during store operating hours and be idle overnight.

The scraping module must handle pages that display prices in various formats like $1,299.00, € 899, or 1299.00 and convert them to integer cents for consistent internal storage.

Output Specification

Produce the following files:

1. competitor-monitor.ts — The competitor price fetching module. It should export a function that accepts a list of competitor configurations (each with a competitor name, product page URL, and CSS price selector) and returns parsed competitor prices. Include the parsePriceCents helper. Include staleness filtering so prices fetched more than 4 hours ago are excluded from results.

2. schema.sql — PostgreSQL DDL for the price history table, including the index needed for efficient per-product price history lookups.

3. price-history.ts — A data-access module that exports a function to record a price change (accepting old price, new price, product ID, and reason) using a database transaction, and also calls a search index update after the transaction.

4. scheduler.ts — Sets up the cron schedule for the pricing job. Should include a comment explaining when the job runs.

Input Files

No additional input files are provided. Implement all files from scratch.

Build a Dynamic Pricing Engine Module

Problem/Feature Description

ShopVelocity is a mid-size e-commerce retailer selling electronics and home goods. Their current pricing strategy is entirely manual: a merchandising analyst updates prices once a week based on gut feel, and the company is losing revenue to nimble competitors who adjust prices hourly. The VP of Product has commissioned a new automated pricing engine that can respond to live signals — how fast a product is selling, how much inventory remains, and what competitors are charging — to adjust prices automatically.

The engineering team needs a self-contained TypeScript module that accepts a snapshot of the current product state and pricing context, runs the decision logic, and produces a recommended price together with the reason for the change. The module must respect two levels of business constraints: hard per-product floor and ceiling prices set by the merchandising team, and an absolute cost-based margin floor that must never be violated regardless of any other rule.

Output Specification

Produce a single TypeScript file pricing-engine.ts that exports:

1. The data types/interfaces for the pricing context, competitor price input, and pricing decision output. 2. A computeRecommendedPrice function that accepts a pricing context and returns a pricing decision.

Also produce a pricing-engine.test.ts file that demonstrates the module working correctly across at least four distinct test cases covering different market conditions (e.g. high demand, near-stockout inventory, competitor price undercutting, slow-moving product). The tests should print their pass/fail result to stdout (use plain console.log assertions or a lightweight test runner — no test framework installation is required beyond what Node.js provides natively).

Input Files

No additional input files are provided. Implement the module from scratch based on the requirements above.

Implement a Price Change Safety Layer

Problem/Feature Description

RetailCore operates a large marketplace with tens of thousands of SKUs. They recently launched an algorithmic pricing engine that has been running for two weeks, but the ops team is alarmed by several incidents: some products swung 40% in a single hour, a few SKUs entered a rapid oscillation cycle where the price kept toggling between two values every 30 minutes, and — most embarrassingly — the engine overwrote the manually configured sale prices during last Friday's flash promotion, confusing customers who saw the advertised discount disappear at checkout.

The engineering team has been asked to build a safety and guardrails layer that wraps the raw pricing recommendations before they are applied to the catalog. This layer must prevent runaway repricing while still allowing the engine to make meaningful adjustments. It also needs to handle the human oversight workflow: large price movements should not be auto-applied but instead queued for a human reviewer to approve or reject.

Output Specification

Produce a TypeScript file price-guardrails.ts that implements the safety layer as a function (or class) accepting a raw pricing decision and the current product record, and returning either an approved decision (possibly adjusted), a queued-for-review record, or a no-op if the change should be suppressed.

Also produce a price-guardrails.test.ts file with test cases covering at minimum: a change that exceeds the single-run cap, a change that requires human review, a change on a price-locked product, a product that was last changed too recently, and a change within normal bounds. Print results to stdout.

Input Files

The following starter file provides the data types you should build upon. Extract it before beginning.

=============== FILE: inputs/types.ts =============== export interface PricingDecision { productId: string; recommendedPrice: number; // cents previousPrice: number; // cents changeReason: string; confidenceScore: number; effectiveAt: Date; }

export interface ProductRecord { id: string; price: number; // cents, current catalog price costPrice: number; // cents lastPricedAt: Date | null; // when the engine last changed this product's price isPriceLocked: boolean; // true when a promotion or manual override is active hasActivePromotion: boolean; }

export interface ReviewQueueEntry { decision: PricingDecision; status: 'pending_review'; queuedAt: Date; }