A pricing pipeline that only ever changes what it's sure about.

Supplier price lists arrive nightly in every shape imaginable. This system turns them into a single, marketplace-ready upload - but its real job is knowing what not to touch.

NightlyScheduled, unattended run

6Stages, each independently checkable

Delta onlyExports prices that genuinely changed

Fail safeRefuses to guess on cost columns

The problem

Pricing sat between two kinds of risk. Update too slowly and the catalog drifts out of step with what suppliers actually charge; update carelessly and a single mangled column can push hundreds of items below cost overnight. The files themselves made both worse - every supplier used different headers, units, and encodings, and a header that merely looked like a cost could be catastrophic if trusted.

The manual alternative was a person reconciling spreadsheets by hand under time pressure, exactly the conditions where a costly mistake slips through. I wanted a system that did the tedious matching perfectly and reserved human attention for the handful of changes that genuinely deserved a second look.

The approach

Six stages, each one you could inspect on its own.

Nothing is a black box. Every stage produces an artifact a reviewer can open - normalized inputs, matched rows, the rules applied, and the exact diff that ships.

Secure file intake

Supplier price files land in structured folders and are collected on schedule - no one has to remember to fetch them.

Normalize & match headers

pandas cleans each file and maps its columns with tolerant matching - but on cost columns it fails safe rather than guess.

Filter to the reference catalog

Only stocked parts from the master catalog move forward, so noise and discontinued lines never reach the pricing rules.

Apply pricing rules

A deterministic engine computes each new price from explicit, testable rules - no opaque model deciding what something should cost.

Anomaly findings

Risky or improbable changes are flagged for review before anything ships - a below-cost result surfaces instead of shipping.

Persist & export the diff

Results land in a database, and the upload file carries only the prices that actually changed - the smallest safe change set.

Stack: Python - APIs - data processing - spreadsheet automation - SQL database - scheduled jobs. A lightweight dashboard lets a reviewer read every change by supplier.

Why it's trustworthy

The safeguards that let it run unattended.

Fail safe on cost

If a cost column can't be matched with confidence, the pipeline stops that file rather than risk pricing from a wrong number.

Deterministic rules, not guesses

Every price is reproducible from explicit rules and inputs, so any output can be explained and re-derived on demand.

Smallest safe change set

Only genuine changes are exported, which shrinks the blast radius and makes each night's diff quick to review.

A reviewer's dashboard

Changes and anomaly findings are browsable by supplier, so a person keeps final judgment without wading through raw files.

The outcome

Pricing that used to be a careful manual chore became an overnight job - one where a person reviews a short, explained list instead of chasing spreadsheets.

The same discipline - map the real process, build on explicit rules, design for review, and operate it like a system - is how I approach every build. You can drive a live slice of this module on the Work page.

Let's talk

Want me to walk you through the decisions behind it?

I'm happy to go deeper on the architecture, the rules, or the trade-offs. Grab a time or send a note.

Book a call Back to work