Skip to main content
Stop pricing chaos across channels with network pricing governance

Stop pricing chaos across channels with network pricing governance

How to build one canonical price architecture that ties price tiers to freshness, controls what each channel can sell, and keeps seasonal and promo overrides from quietly rewriting your margins

Most bakeries don't have a price for their croissant. They have five or six.

There's the number in the POS. There's the chalkboard tag in the pastry case, which may or may not match it. There's the delivery app price, which somebody marked up two years ago and nobody has opened since. There's the wholesale sheet you emailed to three cafes, and the catering PDF that still lists the croissant platter at last spring's price. If you run a loyalty program, there's a sixth "price," which is whatever the free-pastry reward costs you this month.

None of those numbers are wrong on purpose. Each one was right the day someone set it. But they were set by different people, at different times, for different reasons, and nothing connects them. So when costs move, or you launch a seasonal item, or you run a promo, you aren't changing a price. You're changing one of six prices and hoping the other five don't matter.

The fix is a canonical price architecture: one source of truth for price. It maps price tiers to how fresh the product actually is, sets clear rules for which channel gets what, and runs every seasonal or promo override through a lightweight change-control process. It's the plumbing underneath the more tactical pricing work. If prices keep drifting across your counter, apps and accounts, this is probably the layer you're missing.

Follow one price change through the building

The quickest way to see why this matters is to trace one completely normal price change and watch where it leaks.

Butter goes up for the third time in a year. The owner decides the plain croissant moves from $4.25 to $4.60. Reasonable. They update the POS on a Sunday night.

Monday morning goes like this.

The POS rings croissants at $4.60. The case tag still says $4.25, because the person who prints tags works Tuesdays. A regular notices, a barista gives them the old price "just this once," and ends up doing that for maybe a dozen people before lunch. The online pickup menu was built in a separate ordering tool, so it keeps selling at $4.25 until someone remembers it exists, which happens Thursday.

The delivery app has the croissant at $5.00, because two years ago someone added a flat $0.75 markup. That was a decent cushion when the croissant was $4.25 and commissions were lower. Now the app takes somewhere around 28–30%, so out of that $5.00 you keep roughly $3.50–$3.60 before the delivery box. That's well under what you net at the counter, on a product that's at its worst after a 25-minute car ride.

Then there's the coffee-and-croissant combo at $7.00. When the croissant was $4.25 and a latte was $3.75, the combo was a $1.00 discount. Nobody touched the combo, so it's now a $1.35 discount, about 35% deeper than anyone decided. The two wholesale cafes still pay $2.40 a croissant on a handshake agreement with no review date. And the loyalty program's "free pastry after 10" is redeemable on any pastry, so customers, being rational, redeem it on the most expensive thing in the case.

Nothing broke loudly. Nobody complained. But the price increase landed on maybe half the units sold that week, and the channels with the worst unit economics got the smallest increase or none at all.

Pricing chaos usually looks like this. It's rarely one dramatic mistake, just small mismatches across channels that never get reconciled because nobody owns the whole picture.

Why it ends up like this

In most small and mid-size bakeries, channels get added one at a time, and each one shows up with its own price list.

The counter came first, so its prices live in the POS. Online ordering got added during a busy stretch and someone typed the menu into a new tool by hand. Delivery apps came later, and the markup was a guess made during onboarding. Wholesale started when a cafe owner asked "could you do us 40 a day?" and the price got settled in a conversation. Catering has its own PDF because it needed photos.

Every one of those was a sensible local decision. But the result is that prices are entered, not derived. Each channel price is a number someone typed, not a number calculated from a base, and typed numbers don't update themselves.

Ownership is the second problem. Ask a bakery team who owns pricing and you'll hear "the owner." Ask who updates the delivery app and you'll get a different name, or a shrug. Pricing decisions are centralized but execution is scattered, and the drift lives in that gap.

The third one is easier to miss. Bakeries price as if a croissant is a croissant, but a croissant at 7:15am and a croissant at 4:30pm are not the same product, and every customer knows it. Most places handle that informally: someone knocks a dollar off late in the day, or bags up leftovers. Because it's informal, it never makes it into the channel rules, so the delivery app happily sells the 4:30pm croissant at peak price to someone who won't eat it until 5:15.

The canonical price architecture: price by product *and* freshness state

The core idea is easy to say and slightly annoying to set up. Every sellable item gets one base price stored in one place, and that base price is attached to a freshness tier, not just a SKU. Every other price in the business (channel, site, wholesale, bundle, promo) is calculated from that base using a written rule.

Freshness tiers are where this goes beyond a normal price list. Instead of one price per product, you define a small number of windows per product family:

  1. Tier A (peak)

    the window where the product is at its best. Full price, eligible for every channel.

  2. Tier B (held)

    still good, slightly past peak. Full or near-full price, but restricted from channels where it will degrade further, like delivery.

  3. Tier C (late / next-day)

    sold as a different offer entirely. Bundled, discounted, or repurposed, and never sold through channels where the customer expects peak quality.

The markdown mechanics (when to drop price, by how much, how to time it against what's left in the case) are covered in the capacity-aware pricing playbook for perishable SKUs. What matters here is structure. The tiers have to exist inside the price architecture, so channel rules and overrides can point at them. If Tier C only exists as "Dana usually discounts stuff around 4," you can't govern it.

A starting map for a retail-plus-wholesale bakery looks something like this. Your windows will differ based on recipes, climate, and how you hold product, so treat it as a shape, not a spec.

Product familyTier A (peak)Tier B (held)Tier C (late / next-day)Tier C pricing ruleChannels allowed by tier
Laminated (croissant, danish)0–3 hrs out of oven3–7 hrs7 hrs to closeBundle only, ~60–70% of baseA: all · B: counter, pickup · C: counter bundles only
Custard/cream-filled0–4 hrs4–8 hrs (refrigerated)None, no Tier CN/A, discard or staffA: counter, pickup · B: counter only
Enriched (brioche, buns)0–8 hrs8–24 hrsDay 2~65–75% or repurposeA: all · B: counter, pickup, wholesale · C: counter
Lean sourdough / hearth loaves0–24 hrs24–48 hrsDay 3Croutons/toast program or ~50%A & B: all incl. wholesale · C: counter or repurpose
Cookies, bars, shelf-stable0–48 hrs48–96 hrsAfter 96 hrsMixed boxes, ~70%A & B: all · C: counter boxes
Made-to-order cakesPriced by spec, not tier——Not applicablePreorder channels only

Two mistakes come up a lot when people first build this.

First, too many tiers. Three is enough. Five tiers with 10% steps sounds precise, but nobody behind the counter will follow it at 2pm on a Saturday. Staff should be able to apply the tiers without checking a screen.

Second, forgetting that some families shouldn't have a Tier C at all. Custard-filled items are the classic case. Discounting a cream-filled pastry that's been sitting out for nine hours is a quality and safety problem with a price tag on it, and no clever pricing turns that into a good decision.

The floor that sits under everything

Each base price also needs a floor: the lowest price any channel, promo, or override is allowed to produce for that item. The simplest version:

Floor = fully loaded unit cost ÷ (1 − minimum acceptable margin)

If a croissant costs around $1.40 fully loaded (ingredients, labor share, packaging) and you've decided nothing sells below a 55% margin outside genuine clearance, the floor is about $3.10. Tier C clearance can go below the floor, but only inside the clearance rules, never through a promo or a channel formula.

That one distinction catches a surprising amount of damage, because most margin leaks come from promos and channel math, not end-of-day markdowns. It's also a rule people can remember, which counts for more than it sounds.

Channel allocation rules: what each channel can sell, and at what price

Once you have a base price and tiers, each channel gets two rules: a price rule and an eligibility rule.

The price rule is a formula, not a number. For example:

  1. Counter

    base price.

  2. Online pickup

    base price (parity with counter, or customers notice and get annoyed).

  3. Delivery apps

    base × a channel factor (often somewhere in the 1.15–1.25 range depending on commission and terms), rounded to your price ending, plus a packaging adder for items that need a rigid box.

  4. Wholesale

    base × wholesale factor, tied to Tier B for most bread since the account sells it the next day, with a review date and a cost-index clause in the agreement.

  5. Catering

    base × quantity schedule, plus a separate service/packaging line instead of baking those costs into unit price.

Flat-dollar markups on delivery are the mistake I run into most. A flat +$0.75 is fine on a $4 pastry and a disaster on a $1.75 cookie or a $38 cake. Percentage factors with a minimum adder hold up much better as base prices move.

One caveat: some delivery platforms have terms about price parity or caps on markups, so read your agreement before setting the factor. The formula approach still works. You set the factor to whatever the terms allow and fix the economics somewhere else, usually through eligibility.

The eligibility rule decides which products and tiers a channel is even allowed to sell, and this is where the freshness mapping pays off. Delivery gets Tier A laminated product only, and the app listing goes "sold out" once Tier A is gone, instead of quietly selling Tier B pastry that arrives flat and generates a refund. Wholesale gets bread from the planned wholesale bake, not leftovers from retail. Online pickup can sell Tier A and B because the customer collects within a short window.

Eligibility is also about quantity, not just tier. If 120 croissants come out of the first bake, you probably don't want delivery apps taking 70 of them at a worse net than the counter. A simple allocation rule (delivery capped at roughly 20–25% of each laminated batch, counter and pickup protected first) stops one high-volume channel from cannibalizing the rest.

For deciding which channels deserve that protection to begin with, the capacity-aware channel profitability framework walks through the unit math per channel. That's the input. The allocation rule is how you enforce the answer every day.

Bakeries that set channel price rules but skip eligibility rules tend to raise delivery prices over and over, chasing what looks like a margin problem but is really a quality problem. The refunds and bad reviews aren't coming from the price. They come from selling the wrong tier into the wrong channel.

Overrides: where most pricing systems quietly fall apart

Base prices and channel rules cover the steady state, and bakeries don't live in a steady state. You have seasonal menus, holiday items, promos, cost shocks, a new cafe account that wants a deal, a slow Tuesday you want to fix. Each of those is an override, a temporary or scoped change to the normal rules.

The most damaging habit is doing overrides by editing the base price. Someone runs "pumpkin loaf week" by changing the pumpkin loaf price in the POS. The week ends. Nobody changes it back. Or somebody changes it back in the POS but not on the app. Six weeks later you've got three different pumpkin loaf prices and no record of why.

Overrides should be layers that sit on top of the base, never edits to it. Every override needs:

  1. a scope (which SKUs, which sites, which channels)
  2. a rule (a fixed price, a percentage, a bundle definition)
  3. a hard start and a hard end, with the end date required rather than optional
  4. a floor check against the item's floor
  5. a capacity link (how many units per day per channel the override is allowed to sell)
  6. an owner and an approver
  7. a rollback plan

    what the price returns to and who confirms it did

Most bakeries skip the capacity link, and it's the one that causes the operational blowups. A promo that drives demand with no cap on units turns into overselling, rushed bakes, and pulling product from other channels to cover it. If you've been through that, syncing online promos with production through a real-time allocation template covers the allocation side in detail. For governance, all you need is for the override record to require a unit cap before it can go live.

Seasonal items are a slightly different animal. They aren't discounts, they're temporary products with their own base price. Treat them as new SKUs with an end-of-life date built in, assign them to a tier family on day one, and run them through the same channel eligibility rules. A seasonal custard tart doesn't get to go on delivery just because it's new and marketing wants it everywhere.

Override types and how much scrutiny each one needs

  1. Clearance (Tier C)

    pre-approved by the tier rules themselves. No sign-off, just logging.

  2. Routine promo within guardrails

    discount ≤ an agreed limit, stays above floor, has a unit cap, runs under two weeks. Light sign-off.

  3. Seasonal SKU launch

    new base price, tier assignment, channel eligibility. Medium sign-off.

  4. Cost-shock repricing

    base price changes across a family. Full sign-off.

  5. Anything below floor, or any wholesale exception

    full sign-off plus a written reason.

The split matters because if every little promo needs the owner's signature, people stop filing them and go back to editing prices directly. Keep the light stuff light so the heavy stuff actually gets attention.

Change control: templates and sign-off flows

"Change control" sounds like something a bank does. In a bakery it can be a shared form and a 15-minute weekly check-in. The point isn't bureaucracy. It's that every price in the business can be traced back to a decision, and every temporary change has an expiry someone is responsible for.

Change classes

Class 1: Routine. Within existing guardrails (clearance, small promos, rounding fixes). The requester can self-approve, but it has to be logged.

Class 2: Base or seasonal. Changes a base price, adds a seasonal SKU, or changes a channel factor. Needs the owner (or GM) and the production lead to sign off.

Class 3: Structural. New tier definitions, a new channel, wholesale pricing changes, anything below floor outside clearance. Goes to a monthly pricing review, not a Tuesday-afternoon decision.

Most weeks you'll see mostly Class 1 and a handful of Class 2. If Class 3 shows up weekly, your guardrails are probably set wrong.

Price change request template

PRICE CHANGE REQUEST Request ID: PCR-2025-041 Class: 1 / 2 / 3 Requested by: Date requested: Type: base change / seasonal SKU / promo / channel factor / wholesale / clearance / clearance rule Scope SKUs: Product family/tier: Sites: Channels: Change Current base: Proposed base: Resulting channel prices (calculated, not typed): Counter: Online pickup: Delivery: Wholesale: Bundles/rewards affected: Checks Unit cost (current): Floor: Lowest resulting price ≥ floor? Y / N Bundles re-checked? Y / N Loyalty reward value re-checked? Y / N Wholesale agreements affected? Y / N (list) Timing Effective date/time: End date (overrides only — required): Approvals Owner/GM: _ date Production lead: date (Class 2+) Pricing review: date (Class 3) Rollout confirmation (initial + time) POS Case tags Online menu Delivery apps Wholesale notice sent Catering sheet _

The "bundles/rewards affected" line looks fussy, but it's what catches the coffee-and-croissant combo problem from earlier. Every base change should force someone to look at what references that item.

Override record template

OVERRIDE Override ID: OVR-SEA-2025-07 Type: seasonal / promo / clearance / cost-shock / wholesale exception Linked PCR: Scope: SKUs Sites Channels __ Rule: fixed price / % off / bundle definition Floor check: pass / fail (fail requires Class 3) Unit cap per day: Counter Pickup Delivery _ Start: Hard end: Owner (runs it): Approver: Rollback: price returns to on ; confirmed by __ Post-mortem due: (end date + 7 days)

The post-mortem line is the one people want to delete. Keep it, even if it's two sentences. It's how you find out the "promo" that sold 300 units mostly just gave away margin on people who'd have bought anyway.

Sample sign-off flow for a Class 2 change

  1. Request raised. Whoever spots the need (often the owner, sometimes the production lead noticing a cost jump on an invoice) fills out the PCR with the proposed base price only.
  2. Channel prices calculated, not typed. Run the base through each channel formula. In a spreadsheet, the channel columns should be formulas nobody edits by hand.
  3. Floor and dependency check. Confirm every resulting price clears the floor. List every bundle, reward, catering package and wholesale account that references the item.
  4. Production sign-off. The production lead confirms the change won't shift demand in a way that breaks the bake plan. A sharp increase on one item can push customers toward a neighboring item you only bake 30 of.
  5. Owner/GM approval, with an effective date at least a few days out so tags, menus and wholesale notices can be ready.
  6. Staggered rollout on the effective date. Counter and online pickup change together first so parity holds. Then delivery apps, catering sheets, and wholesale notices with their contractual notice period.
  7. Rollout confirmation. Someone initials each channel as done, ideally the same day. Anything not done by close gets flagged at the next morning huddle.
  8. One-week check. Look at units sold per channel versus the prior few weeks, and confirm no channel is still showing the old price. Customers screenshot mismatches more often than you'd expect.

For Class 1, the flow is basically steps 1, 3 and 7. For Class 3, it's the full flow plus a discussion at the monthly pricing review, where you also check whether tier windows still match reality. Recipes change, ovens change, windows drift.

The first month of change control feels like overhead. Around month two or three, someone asks "why is the almond croissant $5.10 on the app?" and the answer is sitting in a record instead of in someone's memory. That's usually when the team stops seeing it as paperwork.

Process diagram

A simple visual like this makes it obvious who owns each step and where a change can be stopped if it fails the floor or capacity checks.

What changes as you grow

At one location with one or two channels, the owner's head is the governance system. That works for a while, and there's no shame in it. The failure point is the second person who sets prices, not volume.

The pressure shifts as you add things.

Adding delivery apps is the first real stress test. It's usually the first channel where prices live in a system you don't control and can't see at a glance, so channel formulas and eligibility rules matter most here.

Adding wholesale brings contracts and notice periods. You can't reprice a cafe account the same day butter goes up. That's why wholesale agreements need a review cadence (quarterly works for most) and an index clause tying price to major ingredient costs, so increases aren't a fresh negotiation every time.

Adding a second or third site is where it gets interesting. Site managers will want local pricing, and sometimes that's legitimate, since a downtown site may support higher prices than a neighborhood one. Don't ban it. Give each site a band: base price ± some agreed range (often a few percent), set at the pricing review and never adjusted ad hoc. Online ordering then has to show the right site price at checkout, which is a common place for things to break when the ordering tool only supports one price per item.

Adding a central kitchen or commissary means you also need transfer prices between sites, and those need the same governance. Otherwise one site looks hugely profitable because it's getting product at an outdated transfer cost.

What doesn't change with scale: exactly one base price per item per tier, and every other number derived from it. Growth adds more derived prices. It shouldn't add more sources of truth.

Real scenario: two cafés, three apps, one wholesale route

Business: a bakery-café with two locations, a small production kitchen behind the first site, online pickup, three delivery apps, and around eight wholesale accounts (mostly coffee shops taking pastry, plus a couple of restaurants taking bread). Roughly 45 active SKUs, plus 6–10 seasonal items at any time.

The problem: prices were managed in four places: the POS, the online ordering tool, each delivery app's merchant portal, and a wholesale spreadsheet. Over about 18 months:

  1. The same sourdough loaf had three different prices across counter, pickup and one app.
  2. Roughly one in ten delivery orders, mostly lower-priced cookies and buns, was netting below fully loaded cost once commission and packaging came out, because of flat markups set years earlier.
  3. A holiday promo ran about nine days past its intended end on two apps because nobody owned the rollback.
  4. Wholesale croissant pricing hadn't moved in over a year, while ingredient costs on that item rose somewhere around 15–20%.
  5. The owner and one manager were spending something like 3–4 hours a week chasing price issues: fixing listings, answering "why was it cheaper yesterday" questions, comping mismatches.

What they changed:

  1. They built a base price sheet with three freshness tiers per family, set floors, and replaced every flat markup with a channel factor plus a packaging adder.
  2. Delivery eligibility was limited to Tier A for laminated and filled items, with daily caps per batch.
  3. Wholesale moved to quarterly reviews with a simple butter-and-flour index clause, with 30 days' notice before the first adjustment.
  4. Every promo and seasonal item went through the override record with a required end date and a named rollback owner.
  5. A 15-minute pricing check got added to the Monday ops meeting.

After roughly three months:

  1. Delivery orders below cost dropped from about one in ten to close to zero. The few left were deliberate (one loss-leader item they chose to keep).
  2. Delivery refund requests for "stale" or "flat" pastry dropped noticeably once Tier B laminated product stopped going out on apps. They didn't track it precisely, but the manager estimated roughly half as many.
  3. Wholesale croissant margin recovered most of what had eroded, and only one of the eight accounts pushed back meaningfully. It stayed after a small volume-based adjustment.
  4. Time spent on price firefighting fell to under an hour a week, mostly the Monday check.
  5. No promos ran past their end date during the holiday stretch. That alone would have covered the setup effort.

Overall revenue didn't jump, and that wasn't the point. Margin per order on the worst channels improved, and the owner stopped finding pricing surprises in the weekly numbers.

When this makes sense

Network pricing governance earns its keep when more than one person can change a price or more than two channels sell the same product. That's the threshold. Below it, you're mostly adding admin.

It also makes sense fast if any of these are true:

  1. you sell perishable laminated or filled items through delivery apps
  2. you have wholesale accounts on fixed prices with no review date
  3. you run more than a handful of promos or seasonal items a year
  4. you're about to open a second site, or already have one
  5. you've had a customer point out a price mismatch between your own channels

If two or three of those sound familiar, don't wait for a bigger problem to justify it. The mismatches are already costing you money, you just aren't seeing them in one place.

When it's a bad idea (or at least premature)

If you're a single-site bakery selling mostly over the counter with a small preorder page, a full change-control process is overkill. A base price sheet with floors, plus a rule that promos always have an end date, gets you most of the value.

Don't build this in the middle of a crisis either. If a cost shock is hitting right now, reprice the obvious items first and build the architecture once things calm down. Designing tier windows while you're also fixing a supply problem tends to produce windows that don't match reality.

And if you don't actually know your fully loaded unit costs, start there. Floors built on guessed costs give you false confidence, which is arguably worse than no floor.

Who should NOT do this

Some bakeries should skip this entirely, or shrink it to a one-page version. It overlaps a bit with the section above, but it's worth saying plainly.

  1. Bakeries where the owner sets every price, sells through one or two channels, and is fine with that. Your head is a perfectly good system at that size.
  2. Teams that won't hold a weekly pricing check. The templates only work if someone looks at them. If the Monday 15 minutes will get skipped every week, the records just become a nicer-looking version of the old chaos.
  3. Businesses that want dynamic, hour-by-hour pricing as the main lever. Tiers give you structured flexibility. If you want to constantly tweak prices based on foot traffic, that's a different model, and in most small bakeries it confuses customers more than it helps.

If you land in one of those groups, you can still keep a single base price per item and a floor next to it. That costs almost nothing and covers the worst of the drift.

A weekly pricing health check

This is what keeps the whole thing from drifting back, and it fits in that Monday meeting. Run through it in order:

  1. Every active override has an end date, and none have passed it without being rolled back
  2. Spot-check 5–6 items

    counter, online pickup, and each delivery app show the price the formula says they should

  3. No channel price is below floor outside of Tier C clearance
  4. Any ingredient cost moves over roughly 5% in the last week are flagged for a possible Class 2 request
  5. Bundles and loyalty rewards still reflect current base prices
  6. Delivery listings for Tier A–only items are switching to "sold out" when Tier A stock is gone, not staying live
  7. Wholesale accounts approaching their review date are on the calendar, with notice sent if needed
  8. Seasonal SKUs within two weeks of end-of-life have a wind-down plan (stop baking date, last sale date)

If more than two of these fail in a week, something upstream is broken. Usually it's a channel that got added without formulas, or an override process someone's bypassing because it feels slow.

Where software helps (and where it doesn't)

You can run all of this in a well-built spreadsheet plus a shared form, and plenty of bakeries should start that way. The architecture matters more than the tooling.

Operational software with some AI automation earns its place in the tedious, error-prone middle. It calculates channel prices from the base automatically instead of relying on someone to update five systems. It flags a delivery listing that doesn't match what the formula says it should be. It refuses to publish an override without an end date and a unit cap, auto-expires promos on schedule, and keeps an audit trail of who changed what. Some platforms will also look at sell-through by hour and suggest tier-window adjustments. For example, if a croissant batch consistently sells out of Tier A by 11am on weekdays, the second bake probably needs to happen earlier, not get discounted later.

What software won't do is decide your floors, your tier windows, or which channels deserve protected allocation. Those are judgment calls about your bakery, your customers and your production capacity. Automate the propagation and the checking, and keep the decisions with people.

Where to start this week

If all this feels like a lot, don't build it at once. The order that tends to work:

  1. Write down one base price per item, in one place, with a floor next to it.
  2. Then find every channel where that item is sold and check whether the price there could be calculated from the base. Anywhere it can't, because someone typed a one-off number, is your first fix.
  3. After that, add freshness tiers to your two or three most perishable product families, since that's where channel mismatches cost the most. Overrides and change control come last, once there's a stable base for them to sit on.

Most bakeries that get through the first two steps find a few mismatches they didn't know about within an hour, usually on a delivery app, sometimes on a wholesale sheet. Fixing those pays for the rest of the project. Everything after that is about making sure the next butter increase lands on every channel at once, instead of on whichever ones somebody remembered.

Most bakeries that get through the first two steps find a few mismatches they didn't know about within an hour, usually on a delivery app, sometimes on a wholesale sheet. Fixing those pays for the rest of the project.

Everything after that is about making sure the next butter increase lands on every channel at once, instead of on whichever ones somebody remembered.

Built for Bakeries Tailored for bakery-specific workflows and inventory needs
Save Time Simplify order processing, inventory, and staff scheduling
Delight Customers Faster order fulfillment and personalized service
Grow Revenue Boost repeat orders and optimize production capacity