Product Catalog Business Logic
Dive into the pricing architecture, governance rules, and billing integrations that power the Commet product catalog.
Business logic & design
This page connects the strategy behind the Product Catalog to the systems that execute it. Use it when you need to translate commercial ideas into catalog configuration or when you must explain pricing logic to stakeholders.
Platform documentation aims at business operators. For SDKs, endpoints, and code samples head to the Developer Library Quick Start.
Accessing the product catalog
The product catalog is available through the Products section in your Commet platform. From here you can:
- View all products: Browse your complete product portfolio with SKUs, descriptions, and tax categories
- Manage list prices: Create and edit standard prices for each product across currencies and segments
- Configure price variants: Set up customer-specific pricing with discounts, markups, or custom terms
- Link to agreements: See which agreements reference specific prices or variants
Why the catalog exists
The catalog solves pricing-complexity management for billing platforms that juggle multiple pricing models and customer-specific terms.
Problems it eliminates
- Custom code for every new price or promotion.
- Sales asking βWhatβs the official price?β vs. βWhat are we offering this customer?β
- Lack of analytics on discount adoption or premium pricing.
- No approval workflow for large enterprise concessions.
- Pricing updates blocked behind engineering queues.
Business outcomes
- Clear list price vs. customer price conversations.
- Accurate analytics for margins, discounts, and product performance.
- Negotiation playbooks that combine list tiers and approved variants.
- Automated governance that flags discounts beyond policy.
- Freedom to support any business model without code changes.
Four pricing layers working together
Prices act as the core building blocks in Commet. Each price defines unit cost, pricing model, currency, billing frequency, and billing type. These prices can be reused across multiple customers, making catalog management efficient and scalable.
Products describe the services you sell:
βββ API Platform β API access with rate limiting
βββ Analytics Dashboard β Reporting and insights
βββ Premium Support β 24/7 help with SLA
βββ Data Storage β Scalable storage
βββ AI Processing β Machine learning servicesProduct: API Platform
βββ List Price: Starter β $50/month, 10K calls included
βββ List Price: Professional β $200/month, 100K calls included
βββ List Price: Enterprise β $500/month, 1M calls included
βββ List Price: Pay-per-use β $0.10 per call, no minimumList Price: Enterprise ($500/month)
βββ Price Variant: Acme Corp β 20% discount = $400/month
βββ Price Variant: MercadoLibre β $500/month, 2M calls included
βββ Price Variant: Startup Beta β 50% discount = $250/month
βββ Price Variant: Enterprise Plus β 10% markup = $550/monthAgreement: Acme Corp β Q1 2025
βββ Item 1: API Platform β Enterprise Plan (20% variant)
βββ Item 2: Analytics Dashboard β Professional Plan (list price)
βββ Item 3: Premium Support β Custom price variant
βββ Contract discount: 5% promo for Q1Each layer keeps analytics intact and separates permanent configuration (variants) from temporary negotiation tools (agreement discounts).
Price reusability and identification
Every price in the catalog has a unique price_id that serves as its identifier across the platform. This allows you to:
- Reuse standard prices across multiple customers without duplication
- Track pricing changes and maintain historical accuracy
- Reference prices consistently in agreements, invoices, and analytics
- Create variants from existing list prices while preserving the relationship
Real-world catalogs
Company: DevTools Inc. β API development platform
- Start with Free β Starter β Pro β Enterprise list prices.
- Add-ons such as Analytics or Priority Support live as separate products.
- Enterprise deals add price variants (20% off, extra seats).
- The agreement bundles everything so billing can generate accurate invoices.
Company: PayFlow β payment processor
- List prices capture standard, volume, and enterprise transaction fees.
- Price variants store negotiated percentage rates and minimum commitments.
- Additional products cover cross-border fees and chargeback insurance.
- Agreements combine multi-product bundles with volume-based approvals.
Company: AIFlow β machine learning platform
- Products: compute hours, data scientist seats, model hosting.
- List prices mix on-demand, reserved, and spot usage offers.
- Variants track high-volume seat discounts and custom GPU bundles.
- Agreements apply temporary promos while variants manage long-term terms.
Understanding Usage-Based Pricing
Usage metrics are the foundation of consumption-based pricing models. They track customer activity and convert it into billable units.
How usage metrics work:
- Define the metric: Create a usage metric that tracks specific customer behavior (API calls, storage GB, compute hours, transactions processed).
- Send usage events: Your application reports usage events to Commet in real-time or in batches.
- Aggregate consumption: The billing engine aggregates usage data for each billing period.
- Apply pricing rules: Your configured pricing model (linear, tiered, packaged) calculates the charge.
- Generate invoices: Usage charges appear as line items with consumption details.
Common usage metric examples:
- API Platforms: API calls, requests per minute, data transfer GB
- Infrastructure: Compute hours, storage GB, bandwidth consumed
- Communications: SMS sent, phone minutes, email deliveries
- AI/ML: Model predictions, training hours, tokens processed
- Payment Processing: Transaction volume, payment count
Pricing flexibility with usage metrics:
Usage metrics can be combined with multiple pricing models:
- Linear: $0.10 per API call
- Graduated tiers: First 100K calls @ $0.10, next 400K @ $0.08, 500K+ @ $0.05
- Volume tiers: 0-100K @ $0.10, 100K+ @ $0.07 (customer pays only their tier rate)
- Packaged: $25 per 1,000 API calls
- With included units: First 10K calls free, then $0.10 per call
- Credit burndown: 50K API credits pack, 1 call = 5 credits
Best practices:
- Name metrics clearly (e.g., "api-calls" not "metric-1")
- Choose appropriate aggregation (sum for API calls, max for concurrent users, unique for monthly active users)
- Set up alerts for unusual consumption patterns
- Provide customers with real-time usage dashboards
- Include usage details in invoices for transparency
Supported pricing models
| Model | Use case | Example |
|---|---|---|
| Fixed / subscription | Predictable revenue, monthly or one-time fees. | $500/month platform fee, $2,500 onboarding |
| Linear usage | Pay-per-use with included units. | $0.10 per API call after 1,000 free calls |
| Percentage-based | Payments or revenue-sharing with safeguards. | 2.9% of transaction value with $0.30 min / $10 max |
| Volume tiers | Customer pays the rate of the tier they land in. | 0β100 units @ $1 + $20 flat, 101+ @ $0.75 + $50 |
| Graduated tiers | Progressive pricing like tax brackets. | First 100 GB @ $1, remaining @ $0.75 |
| Packaged / stair-step | Sell bundles of units. | $10 per 250 SMS sent |
| Seat-based | Billing tied to seat balances. | $50 per admin seat per month |
| Minimum fees | Guarantee baseline revenue. | $500 monthly minimum applied across usage prices |
| Credit burndown | Prepaid credits with rollover. | 2,500 credits pack, 10 credits per API call |
Code-friendly examples live in the developer docs, but the catalog UI exposes each model as configurable options.
Governance rules
When to create a product
- New value proposition or service line.
- Different tax treatment.
- Separate reporting needs.
When to publish a list price
- New segment or market positioning.
- Different commitment period or included units.
- Switching pricing models (fixed vs. usage vs. tiers).
When to use a price variant
- Customer-specific discount or currency.
- Contracted unit changes or volume commitments.
- Long-lived custom terms (not temporary promos).
When to apply agreement discounts
- Ramp-up phases, quarter promotions, or limited-time incentives.
- Layered on top of list prices and variants without breaking analytics.
Multi-tenant flexibility
Each organization running on Commet can configure its own catalog:
- Startup catalog: a single core product with 4 plans, a couple of add-ons, minimal variants.
- Enterprise catalog: multiple products, professional services, dozens of variants with approvals, aggressive discount policies.
The catalog supports both extremes on the same infrastructure, keeping segmentation, discount policies, and reporting separate.
Billing engine integration
All billing internals live in billing-engine.md, but hereβs the high-level handshake:
- Products provide tax categories and descriptions for invoices.
- List prices act as the official baseline for negotiations.
- Price variants inject permanent customer customization.
- Pricing models (fixed, usage, seats, tiers) feed the billing calculator.
- Agreements combine everything and pass it downstream for invoice generation.
function resolveFinalPricing(agreementItem: AgreementItem) {
const listPrice = getListPrice(agreementItem.listPriceId);
let finalAmount = listPrice.unitAmount;
if (agreementItem.priceVariantId) {
const variant = getPriceVariant(agreementItem.priceVariantId);
finalAmount = applyVariantPricing(finalAmount, variant);
}
if (agreementItem.agreementDiscountType) {
finalAmount = applyAgreementDiscount(finalAmount, agreementItem);
}
return { listPrice, finalAmount };
}Integration points with other modules
- Usage module:
price_variant.usage_metric_id β usage_metric.idto track consumption. - Seats module:
agreement_item.quantity_source = 'seat_balance'pulls seat counts automatically. - Tax module:
product.tax_category_id β tax_category.idapplies correct rates per product. - Customer module: optional
price_variant.customer_idto tie custom pricing to a specific account.
End-to-end workflow
- Catalog setup: define the product portfolio and assign tax categories.
- List price design: product marketing publishes official pricing for each segment.
- Negotiation: sales crafts price variants with approvals for custom deals.
- Contract signing: agreements reference list prices, variants, and temporary discounts.
- Billing automation: the billing engine executes the cascade and produces transparent receipts.
Key success metrics
- Zero pricing errors in invoices.
- Full pricing-model coverage without engineering involvement.
- Sub-two-second pricing calculations even with complex tiers.
- No manual adjustments due to catalog limitations.
Troubleshooting common scenarios
| Scenario | Root cause | Solution |
|---|---|---|
| Invoice shows wrong price | Variant or agreement discount not applied | Verify agreement_item links correct price_variant_id and discount settings |
| Tax calculation missing | Product missing tax_category_id | Assign tax category to product before creating list prices |
| Pricing resolution timeout | Complex tier calculations with many variants | Optimize tier structure or cache frequently-used pricing paths |
| Discount approval bypassed | No policy enforcement on variant creation | Enable approval workflows in RevOps settings |
How is this guide?