PLM, Coupa and Syndigo stalled pricing committees; Looker unified inputs for decisions

Overview

A global retailer’s pricing committee struggled to make timely calls because cost inputs from product lifecycle management, procurement updates, and competitor moves arrived in different formats and at different times. Meetings devolved into reconciling spreadsheets instead of choosing an option. Intelligex integrated Centric PLM, Coupa procurement signals, and Syndigo market feeds into a governed data model and exposed it in a real-time Looker dashboard with scenario toggles and an approval-backed change log. The committee shifted from arguing inputs to selecting outcomes, with cleaner decisions, fewer errors, and a transparent trail for what changed and why.

Client Profile

• Industry: Omnichannel retail
• Company size (range): Enterprise with multi-region category teams
• Stage: Established retailer with an active pricing governance cadence
• Department owner: Strategy, Analytics & Executive Leadership (Pricing & Corporate Strategy)
• Other stakeholders: Merchandising, Finance, Procurement, Supply Chain, eCommerce, Store Operations, IT/Data Engineering, Legal & Compliance

The Challenge

Category leaders needed to weigh raw material shifts, landed cost changes, and competitor pricing to set or hold price ladders. Cost elements flowed from bills of materials in product lifecycle management, vendor terms and purchase orders in procurement, and rival pricing from market feeds. Each team maintained its own view of reality in spreadsheets. By the time the pricing committee convened, inputs were stale or incomplete, and critical choices waited while analysts aligned definitions and timing.

The tools already existed. Centric PLM held product and component data, Coupa tracked supplier activity and terms, Syndigo provided market and shelf signals, and Looker supported internal analytics. What was missing was a single model, consistent cut-offs, and a workflow that turned proposed changes into traceable decisions. Leadership asked for a way to see the same facts at the same time, test scenarios, and capture approvals without replatforming core systems or forcing category teams to abandon their working practices.

Why It Was Happening

Data paths were fragmented. PLM and procurement systems used different product identifiers and units of measure, while market feeds referenced consumer-facing identifiers and varied by channel. Finance applied exchange rates and freight assumptions in a separate model. No shared calendar defined when each feed was “final” for a decision, and there was no place to log the committee’s rationale in a way that tied back to the exact inputs used.

Governance arrived too late. Scenarios were built in decks, margins were calculated in personal spreadsheets, and proposed moves circulated by email. There was no approval flow tied to the dashboard, no reason codes for deviations from policy, and no audit view of who changed what and when. As a result, teams spent time reconciling inputs and arguing baselines instead of making the call.

The Solution

We created a governed pricing workspace that unified inputs into a conformed model and presented them in a Looker dashboard designed for decision-making. Centric PLM supplied structured cost and component data, Coupa contributed vendor and landed cost updates, and Syndigo provided competitor and shelf signals. Currency, pack, and product identity were standardized, and a shared cut-off determined the snapshot used in each committee. Scenario toggles let leaders apply policy choices and sensitivity levers, while an approval-backed change log captured the selected option, rationale, and effective date. Nothing was ripped out; existing systems remained systems of record, and the workspace orchestrated them into a single, auditable flow.

• Data ingestion from Centric PLM for bills of materials and cost components (Centric PLM)
• Procurement signals from Coupa for vendor terms, purchase orders, and freight surcharges (Coupa Procurement)
• Market pricing and assortment feeds from Syndigo to track competitor moves (Syndigo)
• Conformed data model with product identity mapping, pack and unit normalization, and currency conversion
• Looker dashboard with scenario toggles for raw material assumptions, exchange rate stance, and competitor alignment, plus guardrails for margin floors (Looker)
• Change-log capture with reason codes and approval workflow; decisions stored with inputs, toggles, and effective dates
• Cut-off policy that freezes a decision snapshot for each committee and renders consistent views across categories
• Role-based views for category managers, finance reviewers, and executives with policy reminders in-line
• Version control for metric definitions and dashboard logic using Looker’s Git integration (Looker Git)
• Notifications to stakeholders when decisions publish, with downstream handoff to pricing operations for deployment

Implementation

• Discovery: Mapped PLM cost structures, procurement fields, and market feed schemas; inventoried product identifiers and units; documented current pricing cadence, margin guardrails, and approval policies; and gathered common reconciliation pain points from recent committees.
• Design: Defined the conformed data model and identity mapping across PLM, procurement, and market feeds; established cut-off rules and freshness checks; designed the Looker decision view and scenario toggles; documented approval paths, reason codes, and audit fields; and aligned on role-based visibility by function.
• Build: Implemented pipelines to ingest PLM and Coupa data and align it with Syndigo feeds; built transformations for currency, pack, and unit normalization; created Looker Explores and dashboards with scenario parameters and guardrails; added a decision write-back and approval queue; and versioned definitions in Git.
• Testing and QA: Replayed recent committees to validate that inputs reconciled and decisions could be recreated from the dashboard; tuned identity mappings and guardrail thresholds; tested cut-off behavior and freshness alerts; verified approval logging and notifications; and pressure-tested performance during live meetings.
• Rollout: Launched read-only views for a cycle so teams could compare the workspace to their spreadsheets; enabled scenario toggles and the change-log in a pilot category; then activated the approval flow and cut-off policy across categories; kept a manual override for urgent moves with documented rationale and post-review.
• Training and hand-off: Delivered quick guides for category managers on using scenario toggles and logging decisions; trained finance on guardrails, definitions, and read-backs; briefed IT on data freshness and identity stewardship; and established a human-in-the-loop process for edge-case mappings and policy exceptions.

Results

Pricing committees worked from a single view of the facts. Inputs arrived aligned and current, and scenario toggles made policy choices explicit rather than baked into private spreadsheets. Decisions were captured with rationale and effective dates, and finance saw that margin guardrails were respected. Downstream teams received clear instructions and did not need to reconstruct why a change was made.

The organization moved faster because conversation shifted from reconciling inputs to selecting options. Errors declined as currency, pack, and identity were handled consistently, and the committee could recreate any decision from the stored snapshot. Category leaders, finance, and procurement reviewed the same dashboard, which strengthened shared ownership and reduced back-and-forth edits.

What Changed for the Team

• Before: Inputs arrived in separate spreadsheets with mismatched identifiers. After: A conformed model unified PLM, procurement, and market data.
• Before: Committees debated baselines. After: Scenario toggles and guardrails framed choices with shared assumptions.
• Before: Rationale lived in emails. After: A change log captured decisions, reasons, and effective dates with approvals.
• Before: Definitions drifted by category. After: Metric logic was versioned in Git and applied consistently across dashboards.
• Before: Hand-offs relied on recollection. After: Downstream teams received decisions with context and traceable inputs.

Key Takeaways

• Unify cost, procurement, and market signals into a single, governed model so decisions start from shared facts.
• Design decision views, not just reports; scenario toggles and guardrails focus conversation on options and policy.
• Freeze a cut-off for each committee and store a snapshot so every decision can be recreated and audited.
• Capture approvals with reason codes and link them to the exact inputs and assumptions used at the time.
• Keep PLM, procurement, and market tools in place; layer orchestration, versioned definitions, and an approval-backed change log.

FAQ

What tools did this integrate with?
We integrated Centric PLM for product and component costs, Coupa for procurement terms and landed cost elements, and Syndigo for competitor and shelf signals. The conformed model powered a Looker dashboard for decisioning. Looker’s Git integration managed version control for metric logic, and notifications routed decisions to pricing operations for deployment.

How did you handle quality control and governance?
Identity mapping aligned product identifiers across PLM, procurement, and market feeds. Freshness checks and cut-off rules ensured each committee used a controlled snapshot. Guardrails enforced margin floors and policy limits. The change log stored decisions with inputs, scenario toggles, approvers, and reason codes. Metric definitions and dashboard logic were versioned in Git to prevent drift.

How did you roll this out without disruption?
We began with read-only dashboards that mirrored existing spreadsheets, then enabled scenario toggles and the change log in a pilot category. After validating with stakeholders, we activated the approval flow and cut-off policy across categories. Core systems remained the same; the workspace orchestrated them into a single decision layer.

Is this truly real-time?
Pipelines refreshed on a cadence aligned to business need and committee timing, with freshness indicators visible in the dashboard. The goal was trusted, current inputs at the moment of decision rather than constant churn. For urgent moves, teams could trigger an ad hoc refresh and capture the cut-off in the change log.

How were approvals and auditability handled?
Proposed price moves were recorded from the dashboard with required fields and reason codes, then routed to the defined approvers. Once approved, the system stored an immutable record linking the decision to the exact inputs, assumptions, and policy checks. This created a repeatable, auditable trail from scenario to selection to deployment.