Pricing Functions:
logic that does things.
AI handles the heavy math — elasticity, seasons, demand forecasts, clustering. Pricing Functions let you compose everything on top of it. Reference them from anywhere. Trigger markdowns, reshape assortment, move entire categories. All from one place you control.
// Classify every product by profit × velocity CASE WHEN {profitPct} > {roleStarThreshold} AND {qtyPct} > {roleStarThreshold} THEN 'Star' WHEN {profitPct} > {nicheThreshold} THEN 'Niche Premium' ELSE 'Laggard' END
| Product | Profit %ile | Qty %ile | Role |
|---|---|---|---|
| Sony 65" QLED | 0.91 | 0.88 | Star |
| Artek Coffee Table | 0.74 | 0.22 | Niche Premium |
| Jack & Jones Sweater | 0.45 | 0.66 | Volume |
| Seasonal Mittens 2023 | 0.12 | 0.08 | Laggard |
| Nike Air Max 90 | 0.83 | 0.91 | Star |
The vendor used to decide what mattered.
Now you do.
Fixed grid.
Fixed thinking.
- Columns the vendor shipped.
- Metrics hardcoded into the UI.
- New rule? File a ticket, wait 6 weeks.
- Real decisions live in Excel files nobody can find.
- Every team member rebuilds the same logic differently.
Composable.
Referencable.
Yours.
- Write any metric, any rule, any classification.
- Reference one Pricing Function from another. Reuse everywhere.
- Change a threshold — markdowns, filters, assortment all update.
- One source of truth. Versioned. Governed. Auditable.
- Ship logic in 30 seconds. Scale it across the catalog instantly.
Three tiers.
Explicit connections.
A substrate of AI at the foundation. A canvas of user-defined logic in the middle. The modules that execute sit on top. Each tier has one job. Every connection between them is explicit — and yours to change.
tier
Modules
The parts of Pricen your team touches every day. Modules listen for what Functions define: when a threshold moves, the module responds. They don't just show data — they act on it.
tier
Pricing Functions
Your logic layer. Classifications, thresholds, role assignments, grade rules, alert flags — anything you used to bury in Excel. Pricing Functions reference each other. And they reach outside Pricen: weather data, Google Analytics, your ERP — anything you pipe in becomes another variable.
tier
AI Substrate
Continuously learning from your real data. Demand elasticity, seasonal patterns, forecast models, competitive signals, clustering — all generated at the foundation and streamed into every Function above it.
Six Pricing Functions.
Six problems solved
before lunch.
Real scenarios from real retailers. Every one of these used to be a ticket, a spreadsheet, or a meeting. Now it's a Pricing Function.
Cluster the catalog in real time
Classify every product as Star, Niche Premium, Volume, or Laggard — based on profit × velocity percentiles that update as sales happen.
Grade pricing inside a family
Enforce that Grade B variants never price above 96% of their anchor. One Function, applied across every family in the catalog.
Market position at a glance
One filterable label per product: below market, below median, above median, above market. Combines with every other filter in Pricen.
Stale pricing alerts
Products above market median AND unchanged for 90+ days get a stale & uncompetitive tag. Weekly digest lands in your inbox.
Omnibus auto-check
Every promo price auto-checked against the EU 30-day lowest. Flagged if non-compliant. No manual audits, ever.
Role change → markdown cascade
When a product drops from Star to Laggard, one Function swaps its target stock. Markdown module picks it up, sells it down. Automatic.
One signal in.
Four modules respond.
A product's role can shift for a dozen reasons — dynamic clustering, assortment edits, seasonal lifecycle, manual reassignment. Whatever the trigger, Pricing Functions pick up the new state and cascade the response through every module that listens.
Role shifts,
from any source
Dynamic clustering re-ranks on new velocity data. An assortment edit reassigns a strategy. Seasonal lifecycle flips a product to "out-of-season". A merchandiser flags it manually. Pricen catches them all — Star becomes Niche Premium, Volume becomes Laggard.
Pricing Functions
react
The targetStock() Pricing Function references the role. A product that was a Star with 8 weeks of cover is now Niche Premium with 4. Every downstream variable that depends on the role recalculates in the same cycle.
Markdown
module activates
The workflow reads the new target, sees current stock is 2× over, and adds the product to the active markdown strategy via a dynamic filter — no human sorting, no manual ticket.
Prices move,
stock clears
Pricen applies the markdown curve, respecting safeguards, until stock hits target. The loop closes without a human touching it.
Get a little weird
with it.
Roles, markdowns, grades — that's where most teams start. But once you have a logic layer that can pull in any data source and reference any other Pricing Function, the scenarios get wild. Four real ones from teams who pushed further.
Follow the
thermometer.
A hard freeze hits Vantaa, and winter windshield washer fluid flies off the shelves. Pipe live weather data into a Function — when the forecast drops below zero, Pricen lifts winter-grade prices to match the surge. When the temperature climbs back above zero, summer formula takes the front shelf. Pricing follows the weather, nobody touches a spreadsheet.
Weekdays and
weekends, two
different shops.
B2B customers order Monday through Thursday, office hours. Consumers hit the site Saturday afternoon. A Function reads {dayOfWeek} and flips the active strategy — margin mode on weekdays, competitive mode on weekends. Every module downstream (promos, markdowns, category positioning) follows the same rhythm.
Let shoppers
tell you your
price is wrong.
Pipe Google Analytics data straight into Pricen as a source. A Function reads traffic and conversion together: high traffic with low conversion means the price is probably too high — flag it for a test. Low traffic with high conversion means the product is under-priced — lift it up. Your pricing stops guessing and starts listening to the funnel.
Bundles that
do the math
for you.
A 6-pack should never cost more than 5× the single-unit price — that's the whole point of a bundle. A safeguard Function enforces it automatically. Edit one single-unit price, and every bundle containing it reprices itself. Change the bundle-discount ratio once, it propagates across the catalog. No drift, no audit, no side-by-side spreadsheet.
If you can describe it
in a sentence, Pricen can
run it as a Pricing Function.
Write it.
Reference it.
Reuse it.
Write a Pricing Function
Open the Function editor. Write or paste an expression. Name it, document it, save. It appears everywhere — in the grid, in filters, in workflows — instantly.
Use variables, not hardcoded values
The {placeholder} syntax pulls in product data or user-defined thresholds. The same Pricing Function works across Kidswear, Menswear, and Footwear — tune the thresholds, not the SQL.
Reference Pricing Functions from Functions
Your targetStock() Function calls productRoleLabel(). Your markdown workflow references targetStock(). A single change at the root updates every downstream effect. No copies to maintain.
Ship to the team
Publish to your org, and every pricing manager uses the same version — by reference, not by copy. Update the source, everyone gets the update. No more "whose spreadsheet is the right one?"
// Target inventory depends on role CASE {productRoleLabel} WHEN 'Star' THEN {weeklyVelocity} * 8 WHEN 'Niche Premium' THEN {weeklyVelocity} * 4 WHEN 'Volume' THEN {weeklyVelocity} * 6 WHEN 'Laggard' THEN {weeklyVelocity} * 1 END
This Function references {productRoleLabel} — another Function. Update role thresholds at the source, and every product's target inventory recalculates. The markdown module sees the new targets on its next cycle and acts accordingly.
Countless Pricing Functions.
Ready in 5 minutes.
Pick a Pricing Function template from the library and you're live in minutes. Need something brand new? Describe it — we'll template it for you in about five minutes flat. No ticket, no roadmap wait, no "we'll get to it next quarter."
Write it, see it,
change it.
Pricing Functions don't disappear into a black box. Everything runs live against your real data — you see what you get, and if it's not right, you fix it on the spot.
Tested
The SQL runs live the moment you write it. Syntax errors, null handling, missing columns, performance issues — all surface right there in the editor. Save only passes when the Pricing Function is actually valid and fast enough.
Immediate results
Hit save and the table loads — every row, every product in your catalog, with the new column filled in. No batch job, no overnight wait, no "check back in ten minutes." You see the results the instant the Function is saved.
Editable
Don't like the output? Open the Function, change the code, save again. The table updates to reflect the new logic in real time. Iterate until it matches your intent — and then, if the logic needs to change next month, change it.
Fast enough to
actually use.
Real measurements from a 160,000-product catalog running on the live Pricen platform. No pre-computation. No nightly batch. No cache to invalidate. Every Pricing Function evaluates live, against your real data, every time you open the grid.
Measured on a live 160,000-SKU catalog · Scales to millions · Pricing Functions evaluate in the same cycle as the grid
Your pricing
brain, finally
programmable.
See how a single Function can restructure how your catalog behaves. 20 minutes. We'll bring the Functions, you bring the pricing problem.
