Pricing Strategy Foundations

Choosing the right pricing strategy is the single most important decision you make for your product catalog. This chapter covers the three foundational approaches and when to use each.

Cost-Plus Pricing

The simplest approach: calculate your total cost per unit and add a fixed markup percentage.

Final Price = Cost × (1 + Markup%)

When to use: Manufacturing, wholesale, or any business where costs are stable and predictable. Works well when you have strong cost visibility and competition is not the primary constraint.

Competitor-Based Pricing

Set prices relative to what competitors charge for similar products. Common strategies include matching, undercutting by a fixed percentage, or premium positioning.

Matching strategy: Keep prices within 2-5% of the market leader. Best for commodity products where differentiation is minimal.

Undercutting strategy: Set prices 10-15% below key competitors. Drives volume but compresses margins.

Premium strategy: Price 20-50% above competitors, justified by brand, features, or service.

Value-Based Pricing

The most profitable but hardest to implement. Price is based on the perceived value to the customer, not your costs.

Key questions to determine value:

• What alternative does the customer compare against?
• How much money does your product save or make for them?
• What is the cost of not solving their problem?

Putting It All Together

Most successful pricing strategies use a hybrid approach. Use cost-plus to establish your floor, competitor-based to assess your market position, and value-based to determine your ceiling. The Pricing Engine Toolkit supports all three through its rule engine.

Dynamic Pricing Models

Dynamic pricing adjusts prices in real time based on market conditions, demand, customer segments, or time. This chapter covers the three main models and includes a working Python implementation.

Time-Based Pricing

Prices change based on time windows: time of day, day of week, seasonal, or event-based.

Examples: Happy hour pricing, weekend rates, holiday surge pricing, end-of-season clearance.

Demand-Based Pricing

Prices rise when demand exceeds supply and fall when demand is slack. Requires real-time demand signals.

Examples: Airline ticket pricing, ride-sharing surge pricing, event ticket pricing.

Segment-Based Pricing

Different customer segments see different prices for the same product. Typically based on purchase history, location, or customer tier.

Python Implementation

Here is a simple dynamic pricing engine you can adapt:

from dataclasses import dataclass
from datetime import datetime, time
from typing import Optional

@dataclass
class DynamicPriceRule:
    name: str
    base_multiplier: float
    demand_threshold: Optional[float] = None
    segment: Optional[str] = None
    active_days: Optional[list[int]] = None
    active_hours: Optional[tuple[int, int]] = None

class DynamicPricingEngine:
    def __init__(self, base_price: float):
        self.base_price = base_price
        self.rules: list[DynamicPriceRule] = []
        self.current_demand = 0.5  # 0.0 to 1.0

    def add_rule(self, rule: DynamicPriceRule):
        self.rules.append(rule)

    def calculate_price(self, customer_segment: str = "standard") -> float:
        multiplier = 1.0
        now = datetime.now()

        for rule in sorted(self.rules, key=lambda r: r.base_multiplier, reverse=True):
            if rule.demand_threshold and self.current_demand < rule.demand_threshold:
                continue
            if rule.segment and rule.segment != customer_segment:
                continue
            if rule.active_days and now.weekday() not in rule.active_days:
                continue
            if rule.active_hours:
                start, end = rule.active_hours
                if not (start <= now.hour < end):
                    continue
            multiplier = max(multiplier, rule.base_multiplier)

        return round(self.base_price * multiplier, 2)

Example Usage

engine = DynamicPricingEngine(base_price=49.99)
engine.add_rule(DynamicPriceRule(
    name="Weekend Surge", base_multiplier=1.25,
    active_days=[5, 6],  # Saturday, Sunday
))
engine.add_rule(DynamicPriceRule(
    name="Premium Segment", base_multiplier=1.40,
    segment="premium",
))

print(engine.calculate_price("standard"))  # $49.99 (no rules match)
print(engine.calculate_price("premium"))   # $69.99 (segment match)

The full toolkit implements these patterns in src/engine.py with priority-ordered rules and margin floor enforcement.