Pricing power is being left
on the table — in both directions.

Three segments, three different pricing problems.

Order history contains enough natural price variation to estimate demand response in the B2C and Retail-wholesale segments. It also contains a systematic pricing error: on multi-unit wholesale lines, reps have been quoting above the quantity-break prices customers are entitled to — under-discounting, not over-discounting — with measurable churn risk attached.

What to do: (1) enforce quantity-break entitlement on every wholesale quote immediately — it is a discipline fix, not a price cut; (2) run controlled markdown tests on 53 over-priced B2C items where estimated elasticity says lower prices earn more profit; (3) inject deliberate price variation into Manufacturing-segment quotes, where two years of flat pricing has made demand response unmeasurable.

What the order history says.

Where demand response is measurable.

Elasticity (ε) is the % change in units sold per 1% change in price. Estimates use only within-item price variation (each item is its own control), which removes item-mix bias. Whiskers show 95% confidence intervals.

How to read this

B2C (ε ≈ −3): a 10% price cut adds ~30% units. With margins above the Lerner optimum, cuts on most items increase profit. Retail wholesale (ε ≈ −0.9): demand barely responds inside the observed ±5% band — these 8 accounts buy on relationship and assortment. Price moves here transfer margin without moving volume, which cuts both ways: broad discounts are wasteful, but overcharging is pocketed silently until the account quietly leaves. Manufacturing: see Experiment 3.

The $47K that customers were entitled to.

For every wholesale line of 2+ units, the billed rate was compared against the quantity-break tier price the line qualified for (price level 1, tier = min(qty, 5)). The excess is concentrated in the largest accounts — the ones with the most leverage to defect.

The quote pipeline tells the same story

Ten quotes is too few for statistical treatment — this is presented as forensic corroboration, not inference. The open Blockster quotes (EST16, 18–20, $6.5K combined) are immediate candidates for re-issue at entitled break prices.

57 items, item-by-item: list, optimal, action.

For each item with sufficient history (≥ 8 months of sales, ≥ 3 distinct price points), the raw item elasticity is shrunk toward the segment pool (ε̄ = −2.95) in proportion to its data weight, then the profit-maximizing price is computed from unit cost via the Lerner rule: p* = c · ε / (1 + ε). Items marked * are LOT-tracked cosmetics.

Projected impact

Applying each p* under constant-elasticity demand to trailing-12-month volumes: revenue on this basket rises from $160K to a projected $303K (volume more than offsets lower prices) and gross profit rises from $79.3K to $98.9K (+$19.5K, +24.6%). Projections carry the model's assumptions (below); the experiment plan exists to validate them before committing the book.

Quote-by-quote guidance.

Three prices per line: floor (never below — escalate), target (open here), stretch (acceptable ceiling). All three are computable from data already on the quote: item, quantity, customer segment, unit cost.

Validate before committing the book.

The estimates above come from natural (mostly promotional) variation. These three controlled experiments convert them into causal, defensible numbers within one to two quarters.

1. Experiment 1 — B2C markdown test (start now, 8 weeks)Pick 20 CUT items, pair each with a comparable control item (same class, similar price point). Reprice test items to max(p*, list × 0.85). Success metric: gross-profit-per-week vs. control, difference-in-differences. Rotate test/control after 8 weeks to confirm symmetry. The Patriarch mattress family runs as its own cell — four SKUs, $10.8K of the projected lift, one merchandising decision.
2. Experiment 2 — Wholesale break enforcement (start immediately, permanent)Not a test — a correction. Quote entitled break tiers on all wholesale quotes. Track win rate, order frequency, and line depth for 90 days against the prior-12-month baseline. Expected cost ≈ $23K/yr of markup; expected return: recovered order frequency at the seven active accounts carrying $1K+ overcharge balances, and re-engagement outreach to Entenmanns and Karmabit armed with a make-good.
3. Experiment 3 — Manufacturing price-variation injection (next quarter)Elasticity is unmeasurable because reps never vary price. Introduce randomized ±3–4% quote-level variation around the break tier (rep-blind if feasible, e.g., rotating "promo codes" by week). Roughly 300 lines per quarter yields a first credible ε estimate for the segment's $1.2M of revenue within two quarters. Cap downside exposure at 4% × affected lines ≈ $6K per quarter.

Everything needed to reproduce this.

Data

NetSuite production account TD3016323. Window: Sep 2024 – Aug 2026 (24 months). Universe: SalesOrd + CashSale lines (mainline='F', taxline='F', item lines, qty ≠ 0, rate > 0), joined to the pricing table (price level 1 — Base Price) at the quantity-break tier min(max(|qty|,1),5). 6,942 of 7,555 lines matched a book price; the unmatched remainder is mostly configurator/decoration items (WS-CFG-*) with no list price. Segments = customer.category: 4 Manufacturing, 7 Retail, 9 B2C, 3 IT. Estimate outcomes from nexttransactionlink (10 estimates, 1 conversion). Costs = item.averagecost.

Estimator

Log-log demand: ln(q) = α_item + ε·ln(p/p_list). B2C: item-month aggregates (monthly unit-weighted avg. realized price vs. monthly units) per item, pooled across 87 items with ≥ 6 months and ≥ 2 price points; ε̂ = −2.954, SE 0.089 (pooled within-item OLS, 941 df). Retail/Mfg: line-level within-item pooling. Item-level estimates shrunk toward the segment pool: ε_item = w·ε̂_item + (1−w)·ε̄, w = months/(months+10). Optimal price by Lerner rule: p* = c·ε/(1+ε), defined only for ε < −1. Profit projections apply constant-elasticity volume response q₁ = q₀·(p*/p₀)^ε to trailing-12-month units.

Queries (SuiteQL, re-runnable)

SELECT
    t.id                 AS tran_id,
    t.tranid             AS doc_number,
    t.type               AS tran_type,
    t.trandate,
    COALESCE(c.category, 0)          AS segment,
    tl.item              AS item_id,
    ABS(tl.quantity)     AS qty,
    tl.rate              AS realized_rate,
    p.unitprice          AS list_price_at_break,
    ROUND(tl.rate / p.unitprice, 4)  AS price_ratio
FROM transaction t
JOIN transactionline tl ON tl.transaction = t.id
                       AND tl.mainline = 'F' AND tl.taxline = 'F'
                       AND tl.item IS NOT NULL
LEFT JOIN customer c    ON c.id = t.entity
JOIN pricing p          ON p.item = tl.item
                       AND p.pricelevel = 1
                       AND p.quantity = LEAST(GREATEST(ABS(tl.quantity), 1), 5)
WHERE t.type IN ('SalesOrd', 'CashSale')
  AND tl.quantity <> 0 AND tl.rate > 0 AND p.unitprice > 0
ORDER BY t.trandate, t.id, tl.item

SELECT COUNT(*) AS cells, SUM(n) AS obs,
       SUM(sxy - sx*sy/n) AS wsxy,   -- pooled Σ(x-x̄)(y-ȳ)
       SUM(sxx - sx*sx/n) AS wsxx,   -- pooled Σ(x-x̄)²   → ε = wsxy / wsxx
       SUM(syy - sy*sy/n) AS wsyy
FROM (
  SELECT itm, COUNT(*) AS n, SUM(lx) AS sx, SUM(ly) AS sy,
         SUM(lx*ly) AS sxy, SUM(lx*lx) AS sxx, SUM(ly*ly) AS syy
  FROM (
    SELECT tl.item AS itm, TO_CHAR(t.trandate,'YYYY-MM') AS mth,
           LN(SUM(ABS(tl.quantity)*tl.rate)/SUM(ABS(tl.quantity))
              / MAX(p.unitprice))            AS lx,   -- ln monthly avg price ratio
           LN(SUM(ABS(tl.quantity)))          AS ly    -- ln monthly units
    FROM transaction t
    JOIN transactionline tl ON tl.transaction = t.id
        AND tl.mainline='F' AND tl.taxline='F' AND tl.item IS NOT NULL
    JOIN customer c ON c.id = t.entity
    JOIN pricing p  ON p.item = tl.item AND p.pricelevel = 1 AND p.quantity = 1
    WHERE t.type IN ('CashSale','SalesOrd') AND c.category = 9
      AND tl.quantity <> 0 AND tl.rate > 0 AND p.unitprice > 0
    GROUP BY tl.item, TO_CHAR(t.trandate,'YYYY-MM')
  )
  GROUP BY itm
  HAVING COUNT(*) >= 6 AND COUNT(DISTINCT ROUND(lx,4)) >= 2
)

SELECT seg, COUNT(*) AS cells, SUM(n) AS lines,
       SUM(sxy - sx*sy/n) AS pooled_sxy,
       SUM(sxx - sx*sx/n) AS pooled_sxx,
       SUM(syy - sy*sy/n) AS pooled_syy
FROM (
  SELECT COALESCE(c.category,0) AS seg, tl.item AS itm, COUNT(*) AS n,
         SUM(LN(tl.rate/p.unitprice))                          AS sx,
         SUM(LN(ABS(tl.quantity)))                             AS sy,
         SUM(LN(tl.rate/p.unitprice)*LN(ABS(tl.quantity)))     AS sxy,
         SUM(LN(tl.rate/p.unitprice)*LN(tl.rate/p.unitprice))  AS sxx,
         SUM(LN(ABS(tl.quantity))*LN(ABS(tl.quantity)))        AS syy
  FROM transaction t
  JOIN transactionline tl ON tl.transaction = t.id
      AND tl.mainline='F' AND tl.taxline='F' AND tl.item IS NOT NULL
  LEFT JOIN customer c ON c.id = t.entity
  JOIN pricing p ON p.item = tl.item AND p.pricelevel = 1
                AND p.quantity = LEAST(GREATEST(ABS(tl.quantity),1),5)
  WHERE t.type IN ('SalesOrd','CashSale')
    AND tl.quantity <> 0 AND tl.rate > 0 AND p.unitprice > 0
  GROUP BY COALESCE(c.category,0), tl.item
  HAVING COUNT(DISTINCT ROUND(tl.rate/p.unitprice,4)) >= 2 AND COUNT(*) >= 3
)
GROUP BY seg ORDER BY SUM(n) DESC

SELECT c.entityid AS customer, c.category,
       MAX(t.trandate)          AS last_order,
       COUNT(DISTINCT t.id)     AS orders_24m,
       ROUND(SUM(CASE WHEN tl.rate > p.unitprice + 0.005 AND ABS(tl.quantity) >= 2
                      THEN (tl.rate - p.unitprice) * ABS(tl.quantity) ELSE 0 END), 2)
                                AS overcharge_vs_break,
       ROUND(SUM(ABS(tl.netamount)), 2) AS revenue
FROM transaction t
JOIN customer c ON c.id = t.entity
JOIN transactionline tl ON tl.transaction = t.id
    AND tl.mainline='F' AND tl.taxline='F' AND tl.item IS NOT NULL
JOIN pricing p ON p.item = tl.item AND p.pricelevel = 1
              AND p.quantity = LEAST(GREATEST(ABS(tl.quantity),1),5)
WHERE t.type = 'SalesOrd' AND c.category IN (4,7) AND tl.rate > 0
GROUP BY c.entityid, c.category
ORDER BY overcharge_vs_break DESC

SELECT e.tranid AS estimate, e.status AS est_status,
       so.tranid AS next_doc, so.type AS next_type, so.status AS next_status
FROM transaction e
LEFT JOIN nexttransactionlink ntl ON ntl.previousdoc = e.id
LEFT JOIN transaction so          ON so.id = ntl.nextdoc
WHERE e.type = 'Estimate'
ORDER BY e.tranid
-- Estimate status codes: A = Open, B = Processed, X = Expired

SELECT s.itm AS item_id, i.itemid AS item_name, s.n AS months,
       ROUND((s.n*s.sxy - s.sx*s.sy) / NULLIF(s.n*s.sxx - s.sx*s.sx, 0), 3) AS elasticity,
       ROUND(POWER(s.n*s.sxy - s.sx*s.sy, 2)
             / NULLIF((s.n*s.sxx - s.sx*s.sx)*(s.n*s.syy - s.sy*s.sy), 0), 3) AS r2,
       p.unitprice AS list_price, i.averagecost AS unit_cost
FROM ( /* item-month sums — inner query of Q2, HAVING n >= 8 and >= 3 price points */ ) s
JOIN item i    ON i.id = s.itm
JOIN pricing p ON p.item = s.itm AND p.pricelevel = 1 AND p.quantity = 1
ORDER BY elasticity

Assumptions & limitations