A Comprehensive and Complete Guide to Pricing of SaaS Products

Pricing a Software-as-a-Service (SaaS) product is one of the most critical and challenging decisions for any software business. The right pricing strategy can fuel growth, maximize revenue, and communicate value to customers. On the other hand, underpricing or overpricing can lead to missed opportunities, churn, and slower growth. In this comprehensive guide, we will delve into all aspects of SaaS pricing: from foundational models and strategies, to practical steps and code examples. By the end, you will have actionable insights to help you set, test, and optimize the pricing for your own SaaS product.

Why SaaS Pricing is Unique and Critical

Before diving into models and tactics, it’s important to understand what makes SaaS pricing special:

Recurring Revenue Model: Unlike one-time purchases, SaaS relies on monthly or annual subscriptions. Every pricing decision affects Monthly Recurring Revenue (MRR) and Annual Run Rate (ARR), making churn (customer cancellations) and upsells central concerns.
Customer Lifetime Value (LTV): Since customers pay over time, your pricing not only determines immediate revenue but also influences lifetime value. A slightly higher price might be justified if it leads to more revenue per account over years.
High Churn Sensitivity: Customers can often cancel at any monthly billing date. If your price is too high relative to perceived value, churn will increase. Conversely, too-low pricing might boost churn indirectly by attracting customers who aren’t as committed to your product.
Product Positioning and Value Perception: Price carries message. A premium price can signal a high-end, full-featured solution, while a low price or free model may attract scrappy startups or hobbyists. Align your pricing with your brand and target segment.
Long Decision Cycles (B2B): In B2B SaaS, buying decisions are often weighed carefully. Pricing flexibility (trials, tiers, custom quotes) can help ease that decision, whereas inflexible or opaque pricing can be a barrier.
Multiple Stakeholders: Often, SaaS buyers (e.g. IT teams, managers, procurement) look for different things: lower cost, specific features, high security. Effective pricing strategies account for these stakeholders.

Overall, SaaS pricing must balance value delivery with business sustainability. You need enough revenue to support the product and company growth, while being attractive and fair in the customer's eyes.

Common SaaS Pricing Models

When structuring your pricing, consider how you charge customers for access to your service. The right model often depends on your product type and customer base. Here are the most common SaaS pricing models:

Flat-Rate (Fixed Pricing): A single product offering at one price. Example: Basecamp used to charge one flat price for unlimited users. This model is simple and transparent, but inflexible — you lose an easy way to upsell power users.
Tiered Pricing: Multiple packaged plans (e.g. Basic, Pro, Enterprise), each with a set of features/limits and a fixed price. Most SaaS companies use tiered pricing because it allows packaging features and value-adds. Each tier targets a different customer segment (e.g. small teams vs. large enterprises). For example, a project management tool might offer 3 tiers with different user-limits, storage, and support levels.
Per-User (Per-Seat) Pricing: Charge based on the number of users or “seats”. Common for collaboration, CRM, or enterprise tools. Example: Many conferencing or collaboration tools charge $X per seat per month. It makes revenue scale with team size, and provides a predictable usage metric. A typical formula:

price = base_price + (num_users × per_user_price)

Example code (Python) for computing per-user MRR: ```python def compute_mrr(user_counts, price_per_user): """ Compute Monthly Recurring Revenue given monthly active user counts and price per user. """ return user_counts * price_per_user

mrr = compute_mrr(user_counts=50, price_per_user=10.0) # $10 per user print(f"MRR = ${mrr:.2f}") # MRR = $500.00 ```

Usage-Based (Metered/PAYG): Charge customers for what they consume (aka Pay-As-You-Go). Common for APIs, infrastructure (AWS, Twilio), or services measured in units (GBs of storage, number of transactions, etc.). Advantage: Customers pay only for what they use, aligning your revenue with their actual value usage. This can lower barriers to adoption but can introduce billing volatility. Example calculation: If you charge $0.05 per API call over a threshold, then a customer using 1,500 calls (with 1,000 free) pays (1500 - 1000) × 0.05 = $25.

def usage_based_charge(units_used, free_units, unit_price): """Calculate usage-based billing with a free-tier threshold.""" billable = max(units_used - free_units, 0) return billable * unit_price

monthly_cost = usage_based_charge(units_used=1200, free_units=1000, unit_price=0.10)

$ (1200-1000)*0.10 = $20
Freemium: A permanently free tier that offers limited functionality, with paid tiers unlocking advanced features. This model can generate a large user base quickly by removing any upfront cost. The challenge is converting free users to paid. For example, Dropbox famously gave free storage to get users on board and then lured them into paying for more space or extra features.
Pros: Rapid user acquisition; network effects; channel for upselling. - Cons: Many free users never convert, and support/maintenance for free users can be costly.
Free Trial: Offer the full product (or a trial version) free for a limited time (e.g. 14 or 30 days). This is not exactly a pricing plan, but a conversion tactic. It removes friction by letting leads experience full value before paying. At the end of trial, aim to convert them to a paying plan. Key advice: make cancellation easy, and send reminders before trial ends.
Per-Feature: Charge based on how many features or modules a customer uses. Each add-on has a price. For example, an ERP product may charge separately for HR, CRM, Accounting modules. This can be very customizable but also complex for customers to understand and compare.
Usage + Tier Hybrid: Many SaaS implement a combination. For example, base tier sets a number of users and fixed fee, plus additional $X per extra user. Or base includes some usage (like up to 100 units) and extra usage is billed.
Flat Rate Per Transaction: A variant of usage pricing where each transaction (sale, booking, message sent, etc.) has a fixed fee. E.g., payment processors charge a percent fee per transaction.

When choosing a model, think about how your customers measure value. If your product’s benefit scales with usage (e.g., more data processed equals more value), usage-based is appealing. If customers usually come as fixed-size teams buying a long-term license, per-seat or tiered may be better.

Pricing Strategy: Value, Cost, or Competition?

Beyond choosing a model, you must decide how you set the actual pricing. Three main approaches to setting price levels are value-based, cost-plus, and competition-based. Often, the best strategy is primarily value-based but also informed by costs and the competition. Here's how they work:

Value-Based Pricing: Set your price based on the value your customers receive. Estimate the business impact or ROI delivered by your product, then extract a fraction of that value. For example, if your software saves a company $100,000 per year in time or overhead, pricing at $10,000 per year captures 10% of the value provided. Value-based pricing often results in higher revenue because it’s tied to outcomes.

Actionable Tip: Survey customers about problems and quantifiable savings (time, money). Use these insights to justify pricing. Frame your plan: “This plan costs $Y per month but saves you X hours of work (worth ~$Z), so it pays for itself.”

Cost-Plus (Cost-Based): Calculate the cost to deliver your service and add a markup. For SaaS, cost often includes hosting/infrastructure costs, customer support, and development costs. This model is simpler but can leave money on the table because it ignores the actual value perceived by customers. Useful when your customers are highly cost-sensitive or when entering a price-competitive market.

Actionable Tip: Determine your gross margin target (e.g., 80%). If each customer costs you $50/month to serve (in infrastructure, support, etc.), you can plan to charge around $250/month to achieve that margin.

Competitor-Based: Set prices relative to competitors. If an entire market has standardized pricing (e.g. most CRM tools start at ~$20/user/month), following market price provides an anchor to customers. You can price at the high end or low end depending on differentiation.

Actionable Tip: Research 3-5 competitors’ pricing. Position your price just above or below based on how your feature set compares. If you offer significantly more, you might justify a premium.

Beyond these, think strategically:

Penetration Pricing: (Customer Growth Focus) Start with a low price to attract a large user base quickly. The goal is market share and volume. This can work well for viral or freemium SaaS (e.g. Slack gave away free accounts and locked advanced features) or when launching in a crowded market. Later, you may raise prices or introduce new paid tiers as product matures.
Price Skimming: (Profit Maximization Focus) Start with a high price (for early adopters with high willingness to pay), and later introduce lower-priced plans for broader adoption. Common in consumer tech (e.g., new high-end gadgets) but rare in SaaS unless your software offers cutting-edge capabilities that only large enterprises need initially.
Psychological Pricing: Subtle tactics such as charm pricing ($49 vs $50), anchoring (showing a high reference price), or bundling (combining multiple features for perceived value). For example, listing a “Standard Plan – $99” alongside a strikethrough “$129 value” can signal a deal. Or offering three tier prices like $15, $25, and $49, where the middle appears more economical per-feature.

In practice, most SaaS leaders use a hybrid approach: they pick a model and base prices on value, but also consider costs and competitors. For instance, one might set a base user seat price of $20 by comparing similar products, then justify it by demonstrating how it saves customers hundreds of hours of work (value).

Choosing the Right Pricing Metric

A pricing metric is the unit of usage or measure on which you base pricing. The right metric aligns the customer’s needs with your revenue. For example, if your SaaS helps companies manage contacts, it makes sense to price by the number of contacts or list size. Some common SaaS metrics:

User Seats: Count of users or seats/licenses. Good for collaboration tools, enterprise software, CRMs, analytics dashboards – basically anything used by teams.
Data Usage: Amount of data stored or processed (GBs per month). Common in storage, analytics, or data-heavy apps.
API Calls / Transactions: Number of events or API calls (like AWS charges by compute seconds or S3 per GB). Ideal for developer tools, communication APIs (like Twilio), etc.
Features/Modules: Each add-on counts as usage (e.g. per agent for a helpdesk, per sender for email marketing, per campaign).
Volume/Quantity: For e-commerce platforms, it could be number of products/listings; for payment software, volume or value of transactions.
Time: e.g., SaaS coworking booking might charge by hours used.

Choosing a metric: Consider what drives value for your customer. If your product saves time per user, “per user” might work. If each sale gives a commission, pricing on transactions fits. Always choose a metric that feels fair and predictable. Examples:

Fiverr (freelancing platform) uses project price, not usage.
Twilio: charges per API call (calls, texts, etc).
Zendesk: charges per agent seat.
MailChimp: charges by subscriber count (contacts) or emails sent.
Sentry (error monitoring): charges based on number of events logged.

Multi-Metric (Hybrid) Pricing: Some products allow multiple metrics. For example, a project management tool might have a base price per seat plus extra for additional storage, or an API product might have a base monthly fee plus usage charges.

// Example: Hybrid pricing calculation in JavaScript const pricingPlan = { name: "Pro", basePrice: 50, // base monthly fee pricePerUser: 10, // additional per-user fee includedUsers: 5, additionalUserPrice: 10 }; function calculateMonthlyPrice(plan, totalUsers) { let price = plan.basePrice; if (totalUsers > plan.includedUsers) { price += (totalUsers - plan.includedUsers) * plan.additionalUserPrice; } return price; }

// Example usage: const monthlyUsers = 8; const monthlyPrice = calculateMonthlyPrice(pricingPlan, monthlyUsers); console.log(Monthly price for ${monthlyUsers} users: $${monthlyPrice}); // Output: Monthly price for 8 users: $80

Tiered Pricing and Packaging

Most successful SaaS products use tiered pricing: they offer at least 2-3 plans with different price points and feature sets. Tiers help serve multiple customer segments (e.g. startups vs SME vs enterprise) and create upsell paths. When designing tiers, consider:

Number of Tiers: Typically 3-4 consumer-friendly tiers. Too many can confuse customers; too few may not capture all segments. A common pattern:

Basic/Starter – Low price, limited features/users, intended for individuals or very small teams. - Pro/Standard – Middle price, more features, for growing teams. - Business/Enterprise – High price or custom quote, unlimited/advanced features, dedicated support, security. - Add-ons – Extra costs for things like additional storage, extra admins, premium support.

Feature Packaging: Decide which features go in which tier. The goal is to make each jump in price feel justified by significantly more value:

Limit something in lower tiers: fewer users, limited support, capped usage, or missing some advanced features. - Include the most important/core features in all tiers, so lower tiers still solve customer's main problem. - Advanced or niche features in higher tiers (e.g. advanced analytics, integrations with corporate tools, or custom branding options).

Anchoring and Decoys: Use pricing psychology. For example, if the plans are $10, $20, and $30, consider making the $30 plan overpriced relative to $20 to make the $20 plan a "good deal." Alternatively, show a "most popular" label on the middle plan to steer customers there.
Consistency: Keep your tiers aligned with usage. If your pricing metric is users, then each higher tier should significantly increase the included user count. If it's features, each tier should unlock a new group of features.
Annual vs Monthly Pricing: Offer both monthly and annual billing. Annual subscription typically comes with a 10-20% discount to incentivize longer commitments. In your pricing sheet, display both, e.g. “$100/mo or $1,080/yr (10% off)”. This boosts cash flow and retention.
Examples:

AI Productivity SaaS: Basic ($19/mo, 5k word limit), Pro ($49/mo, 50k words + priority support), Enterprise ($99/mo, 200k words + API access). - Team Chat Tool: Basic ($0/mo, unlimited users, but search limited to 10k messages), Standard ($6.67/user/mo, unlimited history), Plus ($12.50/user/mo, SSO & compliance features). - Project Management: Starter ($5/user/mo, 3 project limit), Professional ($15/user/mo, unlimited projects, integrations), Enterprise ($25/user/mo, premium support).

Example: Pricing tiers structure in Python

pricing_tiers = [ {"name": "Basic", "price_per_month": 10, "max_users": 3, "features": ["Task Management", "Email Support"]}, {"name": "Pro", "price_per_month": 30, "max_users": 10, "features": ["Basic features", "Time Tracking", "Priority Support"]}, {"name": "Business", "price_per_month": 60, "max_users": 50, "features": ["Pro features", "Gantt Charts", "Custom Reports"]} ]

Function to get price given a tier name and number of users

def calculate_tier_price(tiers, tier_name, users): tier = next((t for t in tiers if t["name"] == tier_name), None) if not tier: return None price = tier["price_per_month"] # Additional user fee if beyond max_users (optional) if users > tier["max_users"]: extra_users = users - tier["max_users"] price += extra_users * 5 # charge $5 for each extra user return price

print(calculate_tier_price(pricing_tiers, "Pro", 8)) # $30 (no extra charge up to 10 users) print(calculate_tier_price(pricing_tiers, "Basic", 5)) # $10 + 2*5 = $20

Freemium, Free Trial, and Entry Levels

Offering a free entry into your product can be a powerful strategy. The two main approaches are:

Freemium Plan: A permanent free plan with very limited features or capacities. It works as an acquisition funnel. Make sure:
It provides some real value, but not everything (so the user will eventually feel the need to upgrade). - It doesn’t cannibalize your paid plans. E.g., limit usage (like 2 projects max) or basic support only. - You include product messaging in the app guiding to the upgrade (soft upsell). - Example: A CRM tool may offer free accounts for up to 3 users and basic email support. Users who need more become paying.
Free Trial: Give full access (or nearly full) for a limited time (often 14-30 days). Tips for effective trials:
Remove credit card requirement initially, so sign-up friction is low. But email/contact collection is still required to follow up. - Provide in-app tours or onboarding to showcase core value quickly. - Send email reminders a few days before the trial ends encouraging conversion. - Offer an easy upgrade path: “Upgrade to Pro and keep your data” at trial end. - Example: A marketing automation tool giving a 14-day trial with all features. After expiring, user must choose a paid plan to continue.

Freemium pros and cons:

Pros: Large user base, network effects, easy word-of-mouth. For small user segments, it’s effectively free marketing.
Cons: Low conversion rates (often <2-5%), can incur costs (support, hosting) for free users. It’s important your free tier is self-service only to avoid burning resources.

Actionable Advice:

Use a metric-based freemium: e.g. “Free up to 100 emails/month” rather than time-based. This automatically blocks only heavy users.
Track how many “freemium users” convert to paid each month. If too low, tweak offers or shorten the free plan’s feature list.
For trials, A/B test trial length or messaging to see what yields best conversion.

Building Your SaaS Pricing Strategy: Step-by-Step

Now let’s outline practical steps you can take to set and refine your SaaS pricing:

Identify Customer Segments and Use Cases

Understand your target customers in detail: their business size, willingness to pay, usage patterns, and key benefits they expect. Segment them by value: e.g., startups vs enterprises may have very different budgets. - Interview or survey potential customers about their needs and budgets. - Use analytics: if you already have users, see how heavy their usage is and how much value they extract.

Define Your Value Metric

Decide on the core metric that correlates with how customers derive value. For many SaaS, it’s number of users, but others like records managed, API requests, or campaigns can match better. The value metric should be: - Intuitive: Easy for customers to understand how usage drives price. - Flexible: Covers different customer sizes (e.g., mid-market with 5 users vs large corp with 500). - Value-aligned: If your product saves money or generates revenue, try to align metric with ROI (e.g. number of transactions tracked).

Choose a Pricing Model

Based on your product and customer, pick a primary model: per-user, usage-based, or a tiered hybrid. Compare with competitors and industry norms. Often SaaS start with per-user/tiered, and later add usage components if needed (or vice versa).

Set Up Tiered Plans

Create at least 2-3 plans: - Entry-Level/Free (optional if freemium or trial plan). - Mid-Tier (Growth) – Most attractive for broad customer base. - Top-Tier (Enterprise) – Highest price for power users, maybe custom quotes. For each plan, list features and limits clearly. Distinguish plans by one or two key factors (e.g. Basic doesn’t include analytics, Pro includes advanced analytics, Business adds SLA support).

Calculate Preliminary Prices

Bottom-Up (Cost-Based): Ensure prices cover your costs plus targeted margin. Compute CAC (Customer Acquisition Cost), support cost per user, hosting/serving cost per usage. - Top-Down (Value/Competition): Check competitor pricing and higher-value estimates. For example, if a competitor charges $99/user, could you undercut or need to justify higher? - Consider testing different price points via spreadsheets or simple models: what is revenue if 100 customers buy at $X versus at $Y? Often a slightly higher price with a small drop in conversion can yield more total profit.

Test and Gather Feedback

Price Sensitivity Interviews: Talk to prospective customers with price proposals (e.g. “would you pay $30 or $50 for X feature?”) - Landing Page Experiments: Create pseudo pricing pages and drive traffic to test conversion (even before product launch). - Existing Users: Survey current users (especially happy ones) to gauge if they think your value justifies more than they pay. You might discover they’d pay more for premium support or a feature.

Create a Pricing Page

Clearly present your plans, with features vs price. - Use comparison tables (design tools or simple HTML/CSS tables). - Highlight the most popular plan (often the mid-tier). - Show both monthly and yearly pricing to let customers see savings. - Include a call-to-action (CTA) on each plan (e.g. “Start Free Trial” or “Contact Sales”).

Implement Pricing in Your Billing System

Use a reliable billing platform (Stripe Billing, ChartMogul, Recurly, etc.) to handle subscriptions, upgrades, and invoicing. Make sure: - You can easily add discounts, coupons, or change prices for specific customers if needed. - Charges are accurately prorated when customers change plans mid-cycle. - You automate renewal reminders and dunning (failed payment recovery).

Monitor Key Metrics

After launch, track: - Conversion Rate: % of trials/free-users converting to paid. - Churn Rate: % of customers cancelling each month/year. - ARPU/MRR Growth: Average Revenue Per User and trends in Monthly Recurring Revenue. - LTV:CAC Ratio: Are you recouping your customer acquisition cost (CAC) in a healthy time? If churn is high, customers might feel the price is too high (or value insufficient). If conversion is low, maybe price barriers or messaging issues.

Iterate and Adjust

Use data and feedback to make small adjustments: - If customers ask for features that don’t justify a full tier, consider an add-on price (e.g., “+10$ for premium support”). - If many enterprises request custom quoting, formalize an Enterprise tier with a starting price. - If sales are too slow, try limited-time discounts or longer trial periods, but measure their impact on revenue vs volume. - Communicate changes carefully to existing customers (grandfather old pricing for a period, if raising prices) to avoid backlash.

Pricing Psychology and Presentation

How you present your prices on the website or in conversations can influence customer decisions:

Charm Pricing: Using $99 instead of $100 makes a price seem lower due to perception (the left digit effect). Many SaaS use round numbers too (especially for enterprise), but small changes (like $97) can psychologically appear cheaper.
Anchoring: List a high-priced option to make mid-range pricing seem reasonable. E.g. adding a prominent “Enterprise” plan at $999 can make $299 look like a steal. This is known as price anchoring.
Bundle Discounts: Bundle features or services (e.g. “Starter + Premium Support”) to increase perceived value. Ensure the bundled price is lower than buying separately.
Limiting Plan Options: Too many choices can cause buyer paralysis. Limit to 3–4 main plans and avoid endless addons on the pricing page.
Communicate Savings: If you offer annual plans at a discount, clearly show “Save 15% vs monthly.” This nudges customers toward longer commitment (and better cash flow).
Call to Action (CTA): Each plan’s button should lead directly to sign-up or contact. Clear CTAs like “Buy Now,” “Start Free Trial,” or “Contact Sales” help conversion.
Trust Signals: Nearby pricing, show social proof like customer logos or testimonials. This positively reinforces the purchase decision.

Example of a simple pricing table markdown (some blogs or docs use markdown tables; adjust for actual site CSS):

| Plan | Price (Monthly) | Users | Features | | ---------- | --------------- | ----- | --------------------------| | Basic | $10 | 3 | Essential features | | Pro | $30 | 10 | Basic + Analytics | | Business | $60 | 50 | Pro + Custom Reports, API |

This visual helps customers compare at a glance.

Calculating Revenue and Unit Economics

Pricing must make sense for your business, not just customers. Here are some calculations and metrics to keep in mind:

Monthly Recurring Revenue (MRR):

( \text{MRR} = \sum (\text{plan price} \times \text{quantity of customers/users at that plan}) ). For a simple per-user model: python subscription_plans = [ {"plan": "Basic", "price_per_user": 10, "users": 20}, {"plan": "Pro", "price_per_user": 20, "users": 15} ] mrr = sum([p["price_per_user"] * p["users"] for p in subscription_plans]) print(f"MRR = ${mrr}") # For Basic: 20 users * $10 = $200; Pro: 15 * $20 = $300; total $500 MRR.

Annual Run Rate (ARR):

Essentially ( \text{ARR} = \text{MRR} \times 12 ). It’s your yearly recurring revenue if nothing changes.

Lifetime Value (LTV):

An estimate: ( \text{LTV} = \text{ARPU} / \text{Churn Rate} ) (if churn is monthly). For a plan priced at $50/month with 5% monthly churn, LTV ≈ $50/0.05 = $1,000.

Payback Period:

The time it takes for a customer to “pay back” the cost of acquiring them. ( \text{Payback Period} = \text{CAC} / \text{Gross Margin per Customer} ). If it takes too long (e.g. >12 months), you might need a higher price or lower CAC.

Example Calculation:

Suppose you have 100 customers: Basic plan (50 customers at $10 each) and Pro plan (50 customers at $20 each). - MRR = (50×$10) + (50×$20) = $500 + $1000 = $1500 - ARR = $1500 × 12 = $18,000 - If CAC is $300 per customer (for Pro) and gross margin is 80%, profit per Pro customer (monthly) is $16. LTV for Pro = $20 / churn. If churn is 4%, LTV = $20 / 0.04 = $500.

Use a spreadsheet or simple scripts to simulate different scenarios (like if sign-up growth accelerates by 10 customers/month, what is MRR in 6 months?).

Implementation: Integrating Pricing into Your Product

Once you decide on prices, implement them in your product flow:

Billing Integration: Use a subscription billing service instead of building from scratch:
Stripe Billing, Recurly, Chargebee, Paddle, etc. These handle card payments, invoices, taxes, proration on plan changes, trials, coupons. - Action: Configure your chosen service with your plans (name, price, billing interval).
Plan Enforcement: In your application logic, enforce the limits of each plan:
E.g., check if user.plan == "Basic" and user.projects >= 3: block creating a new project. - Constantly fetch the user’s current plan for feature gating.
Price Updates: If you change pricing, handle it carefully:
New sign-ups get new prices. Existing customers could be grandfathered (kept on old plan price) for transparency. - For annual plans, wait until renewal to implement new pricing (short history of direct increases can upset customers). - Always communicate upcoming changes well in advance (emails, dashboard notices).
International Pricing: If selling globally, decide if you need local currencies. Stripe, for example, can charge in multiple currencies. Consider rounding rules (e.g., €19.99 vs $17.99).
Taxes and Compliances: Remember tax (VAT/GST) implications for SaaS in different regions. Use a service that auto-calculates these, or embed basic tax rules for key markets.

Pricing Examples and Scenarios

Consider these practical examples of pricing approaches for different types of SaaS:

Example 1: Project Management Tool
Entry Plan: $0/mo (up to 5 projects, 2 users) - Starter: $9/user/mo (up to 15 projects, email support) - Professional: $18/user/mo (unlimited projects, integrations, up to 50 users) - Enterprise: Custom pricing (all features, unlimited users, SSO, dedicated account manager)
Example 2: API Service (Usage-Based)
Free Tier: 5,000 API calls/month free, then - Pay-As-You-Go: $0.01 per API call ($10 per 1,000 calls beyond free limit) - Volume Discounts: Above 1 million calls, get higher thresholds or lower cost per call.
Example 3: Analytics SaaS (Hybrid)
Basic: $50/mo (includes 2 user seats, 5GB storage) - Pro: $150/mo (includes 5 seats, 20GB, premium support) - Enterprise: $300/mo (20 seats, 100GB, dedicated support) - Additional User: +$10/user/mo (over included seats) - Additional Storage: +$5/GB

This way, if a company needs 10 users and 50GB storage on Pro, price = $150 + (5 extra users × $10) + (30GB extra × $5) = $150 + $50 + $150 = $350 each month.

Calculate dynamic price for the analytics SaaS example

plan = "Pro" monthly_prices = {"Basic": 50, "Pro": 150, "Enterprise": 300} included_users = {"Basic": 2, "Pro": 5, "Enterprise": 20} included_storage = {"Basic": 5, "Pro": 20, "Enterprise": 100} user_cost = 10 storage_cost = 5

def calculate_price(plan, users, storage): base = monthly_prices[plan] extra_user_fee = max(users - included_users[plan], 0) * user_cost extra_storage_fee = max(storage - included_storage[plan], 0) * storage_cost return base + extra_user_fee + extra_storage_fee

print(calculate_price("Pro", 10, 50)) # 150 + (510) + (305) = 350

Example 4: AI Content Generation Tool
Plans based on word generation per month: - Starter: $19/mo (50k words) - Professional: $49/mo (200k words, 5 seats) - Enterprise: $99/mo (600k words, 15 seats + priority support) - Overage: $4 per additional 10k words. Here, the pricing metric is words generated. Some customers may easily fit in one tier, while heavy users count overages.

Each example shows a combination of flat fees plus usage where sensible. Notice how bigger plans generally include more of the usage metric (words, users, storage) to avoid punishing successful customers with too many extra bills.

Pricing Best Practices and Tips

Start Simple: In the early days, choose a straightforward model (like per-user or flat) to get market feedback. Complexity can be added later once customers mature.
Avoid “ underpricing” out of fear: It’s a common trap to price too low to get signups. But this can set a low-perceived value anchor, and it’s hard to climb later without churn.
Invoice Clearly: Descriptions on invoices should match plan names (e.g. “Startup Plan – April 2025”). Also, ensure customers see what they’re buying. Clear billing reduces disputes.
Segment Effectively: Don’t mix fundamentally different customer needs in the same plan. E.g., students vs corporate have different price sensitivities. You might offer educational pricing separately.
Grandfathering: When changing prices, consider grandfathering existing customers at their current rate for a time. This goodwill can retain customers if handled transparently.
Communicate Value, Not Just Features: In marketing, emphasize outcomes. Instead of “Unlimited reports”, say “Get 20% more insights for your team”. This helps justify price from the customer’s lens.
Regularly Reevaluate: Market value changes. Schedule a pricing review every 6-12 months. Gauge new feature worthiness and shifts in cost/inflation or competition.

Conclusion

Pricing a SaaS product is part analytics, part strategy, and part art. There’s no one-size-fits-all answer, but the process is universal: understand your customers’ value, test different approaches, and measure the outcome.

Key takeaways:

Decide on a pricing model and metric aligned with how customers use and value your product (per-user, usage, tiered, etc.).
Set prices primarily on value delivered, while ensuring costs are covered and competitiveness is considered.
Use tiers, freemium/trials, and psychological tactics (like anchoring and discounts) to segment users and encourage upgrades.
Always monitor metrics like MRR, churn, LTV, and be ready to iterate. Small changes (a new feature in a tier or a price tweak) can significantly impact growth.
Include code and calculations in your decision-making workflow. Use simple scripts or spreadsheets to simulate revenue across scenarios before finalizing.

By following the principles in this guide – from basic pricing strategies to actually implementing and iterating on prices – you can build a pricing structure that maximizes revenue while keeping customers happy. Remember that pricing is not set-and-forget; it must evolve as your product and market mature. With diligent analysis and customer feedback, you’ll find the sweet spot that balances growth with profitability.