Most conversations about dynamic pricing start with a demand curve and end with a price. That framing is why so many pricing projects stall. The curve is the easy part to draw and the hardest part to know. After a few years of watching teams build these systems, I think the state of the art is less about any single clever model and more about how a handful of ideas fit together: how you represent customer choice, how you decide under constraints, how you learn without burning money, and how you prove afterward that any of it worked.
Model the probability a customer picks each option given what is on offer, not demand for one product in isolation.
Turn the demand model into prices and availability that respect shared inventory and business rules.
Treat every price as both a decision and an experiment, inside guardrails that cap the risk.
Design measurement in from the start, with holdouts or switchbacks, so the system can show its value.
This post walks through those ideas in roughly the order a team runs into them.
Where this started
Dynamic pricing as a discipline was born in airline revenue management, where the problem is almost tidy. You have a fixed number of seats, a departure date, and demand that shows up at random. Every seat sold early is a seat you cannot sell later at a better price, and every seat left empty at departure is worth nothing. In 1994, Gallego and van Ryzin gave the classic answer for setting prices in that situation: the best price depends on both how much inventory remains and how much time is left, and you can say something precise about how it moves. With more stock left you price lower, and with more time left you can afford to price higher [1].
The price moves with stock and time
That result still sits underneath modern systems, mostly through one idea: the value of a unit you have not yet sold. If keeping a seat for a later customer is worth $180 in expectation, there is no reason to sell it today for $150. Practitioners call that number a bid price or opportunity cost, and it turns out to be one of the most useful things a pricing system can show a human, because it explains decisions in a way a forecast never does.
If an unsold seat is worth $180 in expectation to a later customer, selling it today for $150 loses money. That one number explains a pricing decision in a way a forecast never does.
The original models assumed customers behaved independently, as if each fare class had its own private stream of buyers. Anyone who has watched real booking data knows that is wrong. Close the cheap fare and some buyers move to the next one up, some leave, and some were never going to buy at all. Modeling that substitution is what the next generation of methods got right.
Customers choose, so model the choice
The biggest practical upgrade in the last two decades was moving from "demand for product j" to "probability that a customer picks j, given everything on offer." The simplest version is a multinomial logit with a no-purchase option. It is not glamorous, but it captures the thing that matters: raise every price and you lose some customers entirely, while closing one option shifts demand to its neighbors.
Plain logit has a well-known weakness, which is that it assumes the choice between two options does not depend on what else is available. Real customers come in types. Some buy on price, some on quality, and mixing those types in a latent-class model relaxes the assumption without leaving the family. When substitution is clearly stronger within a tier than across tiers, a nested logit does the job.
What I find underappreciated is how much of the quality comes from the likelihood and not the functional form. Historical sales are generated under whatever was available on the day. If your model ignores which options were open, it will read "sold out" as "low demand" and "cheap fare closed" as "customers don't mind paying more." The better approach writes the likelihood conditional on the offer set, so that estimating what would have sold, often called unconstraining, falls out of the model instead of being patched on afterward. This sounds like a modeling detail and is really a data requirement: if you cannot reconstruct what was on offer when, no choice of algorithm will rescue you.
If you cannot reconstruct what was on offer, and when, no choice of algorithm will rescue you. A model that ignores availability reads "sold out" as "low demand."
A few other habits separate strong demand models from fragile ones. Hierarchical Bayesian structure lets thin products borrow strength from similar ones and gives honest uncertainty, which the optimizer can then use instead of ignoring. Gradient-boosted trees are good at the messy residual, such as holidays, events and weather, as long as a structural core keeps elasticities sensible. And the model should output distributions, not points, and be backtested by time block. A random train-test split will flatter you every time.
Deciding: from dynamic programs to choice-based LPs
Once you have a demand model, you need to decide what to do with it. For a single product with a deadline, a dynamic program does the whole job. The value of having x units with k periods left is the best price's expected revenue plus the value of what remains, and you solve it backwards from the deadline. The output is a table indexed by time and inventory. That table has a nice property: it is cheap to look up, so it can run in places where a heavy optimizer cannot.
Real businesses sell many products that draw on shared resources: cabins and flights, rooms and nights, slots and staff. Exact dynamic programming explodes. The workhorse here is the choice-based deterministic linear program. Instead of asking for a price per product, you ask how much time to spend offering each possible set of products, subject to resource limits, with the choice model deciding what each set sells; Liu and van Ryzin's analysis of this formulation is the standard reference [2]. There are exponentially many sets, but you never enumerate them. You solve a small version, read off the shadow prices of the resources, and ask a subproblem which set would most improve things at those prices. That is column generation. With a single logit customer segment the subproblem is easy; with several overlapping segments it is NP-hard, and the practical algorithms are heuristics that work well in testing [3].
The shadow prices that come out are what make this approach pleasant to work with. They tell you what a constraint costs. If a rule capping discount depth is costing the business four points of revenue, the optimizer can say so, and a revenue manager can decide if that is a price worth paying. The same trick works for objectives. Revenue is almost never the whole goal, so the better systems let you trace a frontier between revenue and, say, load factor, and choose a point on purpose.
“Shadow prices tell you what a constraint costs. If a discount cap is costing four points of revenue, the optimizer can say so, and a person can decide if it is worth it.
None of this is confined to airlines. Cruise lines, whose cabins are perishable, bundled and sold through many channels, are a natural fit, and Carnival has published an account of a system that jointly sets prices and allocates cabins across its brands, built on demand prediction and a price-elasticity model [13], while commercial systems such as IDeaS now offer cruise-specific revenue management [14].
Risk deserves a sentence too. Maximizing expected revenue can produce policies that look fine on average and terrible in a bad scenario. Selecting among candidate policies by simulating them against sampled demand and balancing the mean against a lower-tail measure like CVaR is a simple, effective way to ask for something safer.
Learning while earning
Everything above assumes the demand model is right, and it never is. When you do not know the demand curve, every price you try is both a decision and an experiment, which is why there is a whole literature on the tradeoff between earning now and learning for later [5].
The method I reach for first is Thompson sampling, partly because it works well and partly because it is about ten lines of code. You keep a belief about demand at each candidate price. Each period you draw one plausible world from those beliefs, charge the price that is best in that world, observe the sales, and update. Prices that look promising get tried more, and prices that look bad get abandoned, but never completely, because the sampled worlds keep occasionally disagreeing. For network settings with shared inventory there is a version with theoretical guarantees [4].
Here is a toy version with Poisson sales and a Gamma belief per price:
import numpy as np
rng = np.random.default_rng(7)
prices = np.array([40, 50, 60, 70, 80, 90])
true_rate = 20 * np.exp(-0.015 * (prices - 40)) # unknown to the algorithm: expected sales per period
a = np.ones(len(prices)); b = np.ones(len(prices)) * 0.05 # Gamma(shape, rate) prior per price
revenue, best = 0.0, (prices * true_rate).max()
for t in range(400):
lam = rng.gamma(a, 1.0 / b) # sample one plausible demand rate per price
k = int(np.argmax(prices * lam)) # price that is best under the sampled world
sales = rng.poisson(true_rate[k])
a[k] += sales; b[k] += 1.0 # conjugate Gamma-Poisson update
revenue += prices[k] * sales
print("avg revenue/period:", round(revenue / 400, 1), "| oracle:", round(best, 1))
In one run of 400 periods it averaged 872 per period against 893 for an oracle that knows the best price is $70, so about 98 percent, even though it spent the early periods flailing around. It is a classroom example with no inventory, no seasonality and no competitors. But the shape of the behavior is real.
One run of 400 periods: about 98 percent of the oracle, including the early periods spent exploring.
The part that does not carry over from the toy is safety. In a real business you cannot charge $5 for an hour to see what happens. Production exploration happens inside guardrails, with a cap on how much revenue the experiment is allowed to put at risk, and with the probability of each choice written down, because you will need those probabilities later to evaluate what happened. The most valuable experiments are the ones aimed where you are most uncertain and where the decision is most sensitive, and a good system allocates its exploration budget that way.
The part that quietly kills projects
Historical prices were not set at random. They were high because demand was high, and low because it was weak. Regress sales on price and you will find that raising prices seems to go along with selling more, or that customers look much less price sensitive than they are. An optimizer built on that estimate will confidently push prices past what the market bears. This is the endogeneity problem, and it has sunk more pricing models than any numerical issue.
Prices were high when demand was high. A naive regression concludes customers barely care about price, and the optimizer then pushes prices past what the market will bear.
The honest fixes are all some form of getting variation you can trust. Randomization is the cleanest, and when you cannot randomize across customers you can randomize across time blocks, markets or locations. When you only have natural variation, double machine learning gives a principled way to use flexible models for the background relationships and still recover the price effect with valid confidence intervals [6]. Instrumental variables work when a cost shock moves price without touching demand directly.
The cleanest variation. If not across customers, then across time blocks, markets, or locations.
Flexible models for the background, with a valid confidence interval on the price effect.
When a cost shock moves price without touching demand directly.
Wrong-sign or unstable elasticities fall back to a conservative prior until an experiment confirms them.
Whatever the method, I would add a plausibility gate in front of it. If an elasticity comes out with the wrong sign, or swings wildly between folds, fall back to a conservative prior and widen the uncertainty. And whatever you estimate from observational data alone should be allowed to move prices only a small distance until an experiment confirms it.
Predicting is not deciding
There is a subtler issue with the usual pipeline, in which you train a forecaster to minimize prediction error and then hand its output to an optimizer. Not all errors cost the same. A forecast that is off in a way that does not change the chosen price is harmless. One that tips the optimizer toward the wrong price is expensive. "Smart predict-then-optimize" trains the model on the regret its mistakes cause downstream, not on raw error [7].
In practice most teams do not begin there. A cheaper start is to measure decision regret in backtests, which means asking how much value was lost versus the decision you would have made with perfect hindsight, and to calibrate the model where the optimizer is most sensitive. If a material gap remains, decision-focused fine-tuning is the next step.
A forecast error that does not change the chosen price costs nothing. Backtest the value lost versus perfect hindsight, and calibrate where the optimizer is most sensitive.
Prices live in a market
Two things about competition have changed how careful teams are. The first is the temptation to feed competitor prices into the model and follow them. It works until everyone does it. Competitor data is a useful signal, but it is one signal among several, and there are real limits on how it can be collected and shared.
The second is collusion without conversation. Calvano and coauthors simulated reinforcement-learning pricing agents in a repeated market and found that they could learn to sustain prices above the competitive level without any explicit communication [8]. Whether that happens in real markets is still argued over, but the possibility has shaped regulators' thinking. The sensible response for a vendor is dull and practical: optimize each customer independently, never share one customer's prices or plans with another, aggregate and delay anything pooled, and write down how competitor inputs are used. Results from the INFORMS dynamic pricing challenge, which pitted learning algorithms against each other in simulated duopolies and oligopolies, are a good read on how this plays out in a controlled setting: a logit-based algorithm won overall, and a plain lowest-price-matching heuristic was hard to beat [9].
To test policies against reactive rivals before they meet real customers, teams increasingly build a market simulator, an agent-based model calibrated to data, and run both their own policy and plausible competitor responses through it.
Personalization and the law
Charging different people different prices is technically easy and legally touchy, and the ground is moving fast. As of this writing, the picture from public law-firm summaries looks like this. The FTC announced a proposed, non-binding policy statement on personalized pricing in August 2026. It treats it as deceptive to present a personalized price as if it were the same for everyone, and it expects clear disclosure of the fact of personalization, its basis, and the kinds of data used, wherever customers would reasonably expect a uniform price. It also gives examples of circumstances that it considers improper to exploit, such as a medical emergency or travel for a funeral [10]. New York has required a disclosure since November 2025 whenever an algorithm sets a price using personal data [12]. Connecticut, Maryland and New Jersey passed laws in 2026 with different scopes and effective dates, and several of them carve out loyalty programs and genuine discounts [11].
Those are secondary sources about a changing area, so treat them as a map, and get counsel for any specific market. But a few engineering lessons hold regardless. Make personalization a gated capability, not a default, and think of it as a ladder: no personalization, personalized ranking of offers at a single price, targeted discounts off a public price, and only then individualized prices.
Treat personalization as a gated ladder, not a default. Climb only as far as the law and your records allow.
Keep a record of consent, of the exact disclosure text shown with each decision, and of why each decision came out as it did. Block features that signal sensitive or vulnerable circumstances, and audit for proxies of protected characteristics. Put fairness limits, such as a bound on how far apart two people's prices for the same product at the same time can be, into the optimizer itself, not into a report after the fact. And when you can, vary prices through discounts and not through surcharges. It is easier to defend and customers take it better.
Where language models belong
Language models are very good at language and not good at guaranteeing that a number respects a constraint. So the sensible division of labor is to let them handle the words. A manager can say, "be more aggressive on weekends but keep occupancy above 90 percent," and the model turns that into a structured policy change that is validated, checked for feasibility, and shown for confirmation. After a run, it can explain a recommendation in plain language using the optimizer's own outputs, such as the binding constraints and the shadow prices. It should not pick prices, invent explanations that the numbers do not support, or have any route around the guardrails. Every change it proposes should be logged.
Turn a manager's instruction into a validated, feasibility-checked policy change, and explain results using the optimizer's own shadow prices.
No picking prices, no explanations the numbers do not support, and no route around the guardrails. Log every change it proposes.
Making it real
The distance between a model that works in a notebook and one that a business trusts is mostly engineering and process. Policies should live as versioned, reviewable documents, with presets and rollback, so a change in objective is a diff and not a retrain. There should be hard limits on how far and how fast prices move, and switches that can shut things off at several levels. New logic should run first in shadow mode against live data, then on a small slice, and what the downstream system actually received should be checked against what was intended. And measurement should be designed in at the start, with holdouts or switchbacks, because a system that cannot demonstrate its own incremental value tends to get switched off by the first skeptical executive.
What is still hard
Several problems remain open. Most companies have more data than variation, so the best investment, building experiments into normal operations, is also the most neglected. Customers who learn that discounts come late will wait for them, and models that include reference prices and forward-looking behavior are still maturing. Promotions are the clearest example of a place where measurement is hard: the true value of a promotion is the sales it created, minus those that would have happened anyway, minus those it pulled from neighboring products, minus the cost of teaching customers to wait, and almost nobody computes that properly. Decisions at different levels, from long-range capacity down to the offer shown to one person, interact, and passing opportunity costs between those levels consistently is under-explored. And there is no widely accepted open benchmark for pricing problems with inventory, choice, promotions and constraints, so many reported gains come from custom simulators and should be discounted accordingly.
If I had to compress all of this into one piece of advice, it would be to build the stack and not a model: something that learns demand, something that decides under rules the business sets, something that enforces limits, and something that measures honestly. Each piece is individually unremarkable. The value is in having all of them, and in being able to show, with an experiment, that the whole thing earns its keep.
Choice models conditioned on what was on offer, with honest uncertainty.
Optimizers that respect the constraints and objectives the business sets.
Hard bounds on how far and how fast prices move, with switches to shut it off.
Holdouts and switchbacks that prove incremental value.
“Build the stack, not a model. Each piece is individually unremarkable. The value is in having all of them.
Build the pricing stack on one platform
Demand models, optimizers, guardrails, and measurement live in different tools at most companies. Strongly runs ML models, agents, and workflows together, with governance and observability built in, in Strongly Cloud or your own environment.
References
- Gallego, G. and van Ryzin, G. (1994). Optimal Dynamic Pricing of Inventories with Stochastic Demand over Finite Horizons. Management Science 40(8). pubsonline.informs.org
- Liu, Q. and van Ryzin, G. (2008). On the Choice-Based Linear Programming Model for Network Revenue Management. Manufacturing & Service Operations Management. pubsonline.informs.org
- Bront, J. J. M., Méndez-Díaz, I. and Vulcano, G. (2009). A Column Generation Algorithm for Choice-Based Network Revenue Management. Operations Research 57(3), 769-784. pubsonline.informs.org
- Ferreira, K. J., Simchi-Levi, D. and Wang, H. (2018). Online Network Revenue Management Using Thompson Sampling. Operations Research. hdl.handle.net
- den Boer, A. (2015). Dynamic Pricing and Learning: Historical Origins, Current Research, and New Directions. Surveys in Operations Research and Management Science. research.utwente.nl
- Chernozhukov, V. et al. (2018). Double/Debiased Machine Learning for Treatment and Structural Parameters. The Econometrics Journal. arxiv.org
- Elmachtoub, A. and Grigas, P. (2022). Smart "Predict, then Optimize". Management Science 68(1). arxiv.org
- Calvano, E., Calzolari, G., Denicolò, V. and Pastorello, S. (2020). Artificial Intelligence, Algorithmic Pricing, and Collusion. American Economic Review. aeaweb.org
- van de Geer, R., den Boer, A. V. et al. (2018). Dynamic Pricing and Learning with Competition: Insights from the Dynamic Pricing Challenge at the 2017 INFORMS RM & Pricing Conference. arXiv:1804.03219. arxiv.org
- Holland & Knight (Aug. 2026). FTC Proposes Enforcement Policy Statement on Personalized Pricing. hklaw.com
- Greenberg Traurig (Sept. 2026). Algorithmic Pricing Under Fire: State Restrictions on Personalized and Surveillance Pricing. gtlaw.com
- Skadden (Jan. 2026). New York Algorithmic Pricing Law Enacted as Other Jurisdictions Weigh Controls on Price-Setting Technologies. skadden.com
- Carnival Optimizes Revenue and Inventory Across Heterogenous Cruise Line Brands. INFORMS Journal on Applied Analytics 51(1), 2021 (a 2020 Edelman Award finalist); describes YODA, Carnival's system that jointly sets prices and allocates cabins across cruise lengths on the same ship. pubsonline.informs.org
- IDeaS. Revenue Management for Cruises (vendor overview of cruise revenue management practice). ideas.com
The legal and regulatory notes in this post summarize secondary sources, current as of October 2026, and are not legal advice.