Pricing is the single most impactful lever for SaaS revenue growth. A 1% improvement in pricing increases profits by 11% on average (McKinsey), compared to 3.3% for a 1% improvement in customer acquisition and 2.7% for a 1% improvement in retention. Yet most SaaS companies spend weeks on feature development and minutes on pricing. The result: leaving 20-40% of potential revenue on the table.
This guide covers the major SaaS pricing models, when each works best, and the operational implications of each model for your engineering and finance teams.
Model 1: Per-Seat Pricing
Per-seat (per-user) pricing charges based on the number of users on the account. It's the most common SaaS pricing model because it's simple to understand, predictable for both vendor and customer, and scales naturally with the customer's organization size.
Examples: Slack ($8.75/user/month), GitHub Teams ($4/user/month), Jira ($7.75/user/month), Figma ($15/editor/month)
When it works: Collaboration tools where value increases with more users. Products where each user has a distinct workspace or needs individual access controls. Products where usage correlates roughly with the number of users.
When it fails: Developer tools where one engineer might use the product intensively and another rarely. Products where value comes from API calls or data processing, not human interaction. Products where "who counts as a user" is ambiguous (does a read-only viewer count?).
Engineering implications: User management is your billing axis. You need: accurate user counting, user type differentiation (admin vs. member vs. viewer), enforcement of seat limits, and the ability to handle mid-billing-cycle user additions (proration).
Model 2: Usage-Based Pricing
Usage-based pricing (also called consumption-based or pay-as-you-go) charges based on actual usage: API calls, data processed, messages sent, storage consumed, or compute hours used. It's the fastest-growing pricing model in SaaS — OpenView's 2025 survey found that 61% of SaaS companies now have a usage-based component, up from 34% in 2021.
Examples: AWS (compute hours, GB transferred), Twilio ($0.0079/SMS sent), Snowflake (compute credits), Stripe (2.9% + $0.30 per transaction), Vercel (function invocations)
When it works: Products where value directly correlates with usage. Products used by both small and enterprise customers (usage-based naturally scales from $10/month to $100K/month). API-first products. Products where "how much should I pay?" is obvious from the customer's perspective.
When it fails: Products where customers can't predict their usage (causes budget anxiety). Products where the value metric is unclear or arbitrary. Early-stage products where you want predictable revenue for financial planning.
Engineering implications: Usage-based pricing requires: real-time usage metering (you must count every API call, every byte, every event), usage aggregation and billing pipeline (aggregate usage into billing periods, apply pricing tiers, generate invoices), usage dashboards for customers (they need to see their usage in real-time to avoid bill shock), and usage alerts (notify customers before they hit spending thresholds).
// Usage metering architecture
// Every billable event goes through the metering pipeline
interface UsageEvent {
tenantId: string;
eventType: 'api_call' | 'storage_gb' | 'compute_seconds' | 'emails_sent';
quantity: number;
timestamp: string;
metadata: Record<string, string>; // endpoint, region, etc.
}
// 1. Emit usage events from your application
async function recordUsage(event: UsageEvent) {
// Write to a high-throughput event store (Kafka, Redis Streams)
await kafka.send({
topic: 'usage-events',
messages: [{
key: event.tenantId,
value: JSON.stringify(event),
}],
});
}
// 2. Aggregate usage in real-time (consumer process)
// Maintains running totals per tenant per billing period
// Stores in Redis for real-time dashboard queries
// Periodically flushes to PostgreSQL for billing
// 3. Billing pipeline (runs at end of billing period)
// Reads aggregated usage from PostgreSQL
// Applies pricing tiers:
// 0-10,000 API calls: $0.001/call
// 10,001-100,000: $0.0008/call
// 100,001+: $0.0005/call
// Generates invoice and charges payment methodModel 3: Feature-Tiered Pricing
Feature-tiered pricing offers different feature sets at different price points: Free, Starter ($29/month), Professional ($79/month), Enterprise (custom pricing). The price difference reflects the value of the features included, not the volume of usage.
Examples: HubSpot (Free, Starter, Professional, Enterprise), Notion (Free, Plus, Business, Enterprise), Zoom (Basic free, Pro $13.33/month, Business $18.33/month)
When it works: Products with clearly differentiable feature sets (basic vs. advanced analytics, single user vs. team collaboration, basic security vs. SOC2 compliance). Products targeting multiple market segments (startups vs. mid-market vs. enterprise).
The golden rule of tier design: Each tier should be designed for a specific customer persona, not just progressively more features. Free = individual user (tries the product). Starter = small team (willing to pay, needs collaboration). Professional = growing company (needs integrations, analytics, SSO). Enterprise = large organization (needs security, compliance, SLA, custom contracts).
Model 4: Hybrid Pricing (The Modern Default)
Most successful SaaS companies in 2026 use hybrid pricing: a base subscription (per-seat or flat fee) plus a usage-based component. This provides predictable base revenue while capturing additional value from heavy users.
Examples: GitHub ($4/user/month + $0.008/compute-minute for Actions), Vercel ($20/user/month + usage for bandwidth/functions), HubSpot ($45/month base + per-contact pricing for marketing hub)
The hybrid model works because: it provides predictable revenue for financial planning (base subscription), it captures value from heavy users (usage component), it reduces friction for light users (low base cost), and it naturally aligns price with value as customers grow.
Pricing Page Design That Converts
Your pricing page is one of the most visited pages on your site. Design principles that convert:
Three tiers maximum on the pricing page. Psychological research (Hick's Law) shows that more options cause decision paralysis. If you have 5 tiers, show the 3 most popular and link to a comparison table for the rest.
Highlight the recommended tier. Use visual emphasis (different color, "Most Popular" badge, slightly larger card) to guide buyers toward the tier with the best revenue/value balance. This is typically the middle tier.
Show annual pricing by default. Display annual pricing (with the per-month equivalent) as the default, with a toggle for monthly pricing. Annual pricing reduces churn, improves cash flow, and looks cheaper per month.
End prices in 9. $29/month, $79/month, $149/month. Charm pricing works. It shouldn't, but it does.
Include social proof. Logos of recognizable customers, testimonials, and "trusted by X,000 companies" on the pricing page reduces purchase anxiety.
Free Tier Strategy: Acquisition Engine, Not Charity
A free tier is a customer acquisition channel, not a product feature. Design it to: (1) give enough value that users become dependent on the product, (2) create natural upgrade triggers ("You've reached 1,000 API calls this month. Upgrade to Pro for unlimited."), and (3) generate word-of-mouth (free users recommend the product to colleagues who become paying users).
The free tier should be generous enough to be genuinely useful but limited enough that growing teams naturally outgrow it. Common limits: 3 users, 1,000 API calls/month, 5 projects, community support only, no SSO, no audit logs.
Metrics That Matter for Pricing Optimization
ARPU (Average Revenue Per User): Track monthly and segment by plan. If ARPU is declining, your pricing doesn't scale with customer growth — you need usage-based or expansion pricing.
Net Revenue Retention (NRR): Revenue from existing customers this year vs. last year, including expansions, contractions, and churn. Best-in-class SaaS companies achieve 120-140% NRR. If yours is below 100%, customers are shrinking or churning faster than remaining customers are expanding.
Price sensitivity testing: Use Van Westendorp's Price Sensitivity Meter or Gabor-Granger analysis to find the optimal price point. Survey customers: "At what price would this be too expensive? A bargain? Starting to get expensive? Too cheap to trust?"
ZeonEdge helps SaaS companies implement pricing infrastructure — usage metering, billing pipelines, subscription management, and pricing page optimization. Schedule a pricing strategy consultation.
Emily Watson
Technical Writer and Developer Advocate who simplifies complex technology for everyday readers.