The Art of Pricing Commercial Open Source
Choosing the Right Model, Building the Right Tiers, and Finding the Right Number
Most COSS founders pick a number too early and then guard it like a fortress. They settle on something that feels defensible, publish it, and refuse to touch it again, because changing prices feels like breaking a promise. The instinct is backwards. A price is a hypothesis. You test it against what people will actually pay, you update it as you learn, and you change it when the product changes. Your pricing page should report what you’ve figured out, not what you guessed in month three.
This post covers the mechanics. Which model fits which kind of product, how to build the tiers, how to find the right number through real sales conversations, and what specific COSS companies charge today.
The five models and what each one really prices
There are five ways COSS companies charge, and each one bets on a different thing being the source of value.
Usage-based pricing charges for consumption: API calls, GB ingested, compute hours, eCKUs (metered capacity unit for Kafka clusters). It fits infrastructure and data tooling, where usage swings wildly from one customer to the next, and it fits cloud-native products you can meter cleanly. Confluent bills in eCKUs, Elastic in GB ingested, and MongoDB Atlas in cluster hours. The bet is that value tracks volume.
Seat-based pricing charges a fixed monthly fee per active user. It fits collaboration tools and DevOps platforms, where value grows with the size of the team. GitLab charges $29 per user per month for Premium; Grafana Cloud charges $55 per user per month. The bet is that value tracks headcount.
Feature-gated pricing, the open-core model, gives away a real core and puts proprietary enterprise features behind a paywall. It fits products where what an enterprise needs separates cleanly from what an individual needs. HashiCorp Vault and Nextcloud both work this way. The bet is that you can draw a clean line between the free thing and the paid thing.
Support-tiered pricing gives the software away and sells the SLA. It fits infrastructure OSS where the paid value is operational reliability: someone on the other end of the phone when production is down at 2am. OpenProject runs this way, and so did the older Red Hat model. The bet is that customers will pay for the guarantee, not the bits.
Hybrid pricing combines them. A seat-based base with usage layers on top, or a platform fee plus consumption credits. It fits most modern COSS, especially anything with AI features or consumption patterns too messy for a single meter. HashiCorp’s HCP Terraform prices on resources; Elastic stacks compute and support tiers. The bet is that no single meter captures the value, so you use two.
Match the model to where the value lives
The model isn’t a style choice. It follows from where value actually accumulates in your product, and getting that wrong mis-prices you systematically.
For developer infrastructure, databases, and streaming, usage-based or hybrid wins, because value is tied to data volume, query throughput, or compute. MongoDB Atlas charges by the hour per cluster. Confluent charges in elastic compute units that autoscale. Elastic Cloud charges per GB ingested and retained. The detail that trips people up: discounts should get better as usage climbs, so the customer who commits hard pays less per unit than the one dabbling at spot prices. Reward the commitment, not the dabbling.
For DevOps, security, and CI/CD platforms, hybrid works. Resource-based plus seat-based. HashiCorp moved off pure seats to Resources Under Management in June 2023, charging $0.10 to $0.99 per resource per month depending on tier. GitLab went the other way and stayed on pure seats: free with unlimited users, then $29 per user per month for Premium, then a custom quote for Ultimate. Both work, because in each case the meter matches the value.
For observability and monitoring, the pattern is usage-based with a genuinely generous free tier. Grafana charges per metric series ($6.50 per thousand), per GB of logs, per GB of traces, and keeps a permanent free tier under all of it. The per-unit price drops as you consume more, which is what turns a small monitoring footprint into a land-and-expand account without anyone making a phone call.
For collaboration and project management, seat-based still fits, because here value really does equal the number of collaborators. Mix in usage limits on compute minutes or storage to nudge teams toward higher tiers so growth comes from real expansion rather than seat arbitrage.
The market has been drifting toward hybrid for a few years. Bain & Company found 85% of SaaS leaders now use some form of usage-based or hybrid pricing, with 61% on hybrid models by 2025. The shape that keeps winning is the same one. A base subscription, a seat or a platform fee gives the customer a predictable floor. A usage layer of credits, tokens, or compute units lets revenue expand with value.
The canonical tier ladder
Each tier sells to a different buyer and unlocks a different kind of value. The ladder runs from the individual deciding to try your product to the organization deciding to standardize on it.
Community or Free is the individual developer’s tier, and it has to be genuinely useful. Not a demo, not a crippled trial. This tier is your distribution. If it’s too thin to be worth running, it generates no community, and you’ve quietly broken the engine that feeds every tier above it.
Team or Pro is the collaboration tier. It adds what a team of two to twenty needs: shared state, basic collaboration, somewhat higher usage limits, and better support. For seat-based products it usually lands between $10 and $50 per user per month.
Business or Growth is the tier for the company that’s scaling. It adds what you need to manage twenty to two hundred people: governance, more integrations, volume pricing, and standard SLAs. This is often where mid-market lands and stays.
Enterprise is the large-organization tier, and it’s where the security and compliance machinery lives. SSO and SAML, SCIM, audit logs, compliance certifications, dedicated support, and custom SLAs. You quote it rather than list it, and a typical ACV runs from $25K to north of $500K.
Rules that actually move the number
Guessing in a spreadsheet doesn’t work. Here’s how to find the price instead.
Start with the friction test. Bessemer Venture Partners’ AI pricing playbook lays out a process simple enough to run in a live call. Name a price, say $12K a year. If the customer says “sold” before you finish the sentence, you’re too cheap. Raise it incrementally until you hear “we’ll have to think about that.” Then stop, just short of where it becomes a real blocker. Run this in actual sales conversations, not a survey, and track how the answers cluster at each price point. The distribution tells you where the elasticity lives. Their hesitation is data. Their enthusiasm is a warning.
Never compete on price in open source. Your product is free to download and run, so if you find yourself in a price war with your own community edition, you’ve got a feature-placement problem wearing a pricing costume. The 2024 Open Source Founders Summit consensus is blunt: pricing too low is a strategic error because it trains customers to read your product as a commodity. It isn’t one. You’re selling operational simplicity, compliance readiness, and reliability that someone is accountable for.
The features that reduce organizational risk command the biggest premium. Compliance, governance, and security controls can carry three to five times the price of features that merely make someone more productive. The reason is structural. Compliance is a hard requirement with no substitute; a productivity gain is nice to have. The buyer with a mandate doesn’t negotiate the way the buyer with a preference does. Price the mandate accordingly.
For an early-stage usage-based product, a workable starting formula is a platform fee of twice your delivery cost, plus usage or outcome credits on top. The 2x floor means the baseline never loses you money, and the credits let consumption expand on its own.
Four pricing pages and what each one gets right
The theory is easier to trust once you’ve seen it survive contact with a real pricing page. GitLab, Grafana, MongoDB, and Confluent all reach billion-dollar scale on the same two moves: tier by who’s buying and let usage expand the bill underneath. Each one emphasizes a different piece. GitLab the buyer-based split, Grafana the metered ladder, MongoDB the clean cloud-versus-on-prem divide, Confluent the compute-unit model. Each of these is accurate as of July 19, 2026. Read them as four angles on one pattern rather than four separate playbooks.
GitLab: role‑based tiers on top of a complete DevOps core
GitLab’s pricing and tiering starts from the buyer and radiates out to features.
Free: Targeted at individual contributor developers, Free is a complete DevOps solution with capabilities across all GitLab stages, including core source code management, collaboration, and CI/CD, but with limited compute minutes and no enterprise readiness or security features.
Premium: Aimed at director‑level buyers and teams, Premium adds “enterprise level support, enterprise readiness features and DevOps features required for growing and multiple teams,” with pricing themes like faster code reviews, advanced CI/CD, enterprise agile planning, release controls, and self‑managed reliability.
Ultimate: Designed for executive‑level buyers and entire organizations, Ultimate’s pricing themes are advanced security testing, security risk mitigation, compliance, portfolio management, and value stream management; Ultimate’s “key value is Security,” bundling DevSecOps, compliance dashboards, and broader insights.
GitLab’s handbook literally maps tiers to “Likely Buyer: Individual Contributor / Manager or Director / Executive” and uses that lens to decide which feature sits in which tier, making buyer‑based tiering explicit rather than implicit.
Grafana Labs: free observability, then pay‑as‑you‑grow
Grafana Cloud turns its open‑source foundation into a three‑step SaaS ladder: Free, Pro, and Enterprise.
Free: “Always free” and “perfect for personal projects, exploring new ideas, and early‑stage startups,” Free includes all Grafana Cloud services with usage limits and about 14 days of retention for metrics, logs, traces, profiles, and k6 performance tests, plus community support.
Pro: A self‑serve tier “from $19/month + usage,” Pro keeps all services but switches to pay‑as‑you‑go above the free limits, with extended retention (e.g. 13 months for metrics, 30 days for logs/traces/profiles/k6) and 8×5 email support.
Enterprise: A full‑service offering starting at a $25,000/year spend commit, aimed at companies with security, compliance, and deployment requirements, adding premium support, custom retention, and deployment flexibility (public cloud, federal cloud, or BYOC).
Every step builds usage‑based expansion into the plan: metrics, logs, traces, and profiles are all metered, and moving up tiers mainly adjusts included usage, retention, support, and deployment guarantees rather than changing the core product.
MongoDB: clean separation of cloud vs. on‑prem paths
MongoDB’s commercial story preserves a clear separation between managed cloud (Atlas) and on‑prem or BYOC enterprise subscriptions.
Atlas Free: Atlas exposes a free shared cluster tier (commonly M0) with constrained storage and performance, giving developers a no‑cost way to start building on MongoDB in the cloud.
Atlas Dedicated: Dedicated Atlas clusters are billed usage‑based (instance size, region, consumption), with public guides showing small dedicated instances priced at a few cents per hour and scaling up with workload size.
Enterprise Advanced: MongoDB’s Enterprise Advanced subscription targets on‑premise or bring‑your‑own‑cloud deployments and bundles advanced security, compliance, and SLAs, keeping the enterprise path for self‑managed environments distinct from the Atlas SaaS path.
This pattern keeps the cloud “pay for what you run” path clean, while giving regulated or large enterprises a separate “subscription + SLA” track for on‑prem/BYOC.
Confluent: usage‑based streaming with tiered readiness
Confluent commercializes Kafka and streaming workloads through Confluent Cloud, built around compute units and tiered cluster offerings.
Cluster tiers: Confluent Cloud offers cluster types like Basic, Standard, and Enterprise (with specialized options such as Freight), each tuned to different workload and reliability profiles—from development and smaller production workloads up to mission‑critical, highly regulated deployments.
Usage‑based pricing: Across tiers, pricing is primarily usage‑based: clusters are billed for elastic/compute Kafka units (eCKUs/CKUs) on a per‑hour basis, plus networking and data operations per GB and per request, so cost tracks throughput, storage, and retention rather than seats.
Enterprise value: Higher tiers add stronger SLAs, private networking options, and governance and compliance features, aligning spend with operational risk and regulatory requirements.
The net effect is an elastic compute‑unit model where streaming cost scales in line with data volume and workload intensity, while tier labels signal what level of reliability and control you’re buying. The clearest way to see these rules at work is to read the pages of companies that priced well. Tier data first, then what the page is doing.
Seven ways pricing goes wrong
Most pricing mistakes repeat. Here are the ones that show up again and again in COSS.
Leaving off a “Contact Sales” path. Self-serve handles deals under $25K cleanly. Above that, the buyer wants to negotiate, ask about custom terms, and put a name to the person accountable for the relationship. Hide the contact button and you don’t look streamlined. You lose the enterprise deal.
Too many tiers. Four is the ceiling before decision cost starts killing conversion. If you have eight, the customer doesn’t study them admiringly. They stall. And a stalled customer buys nothing. Consolidate.
A free tier that’s too weak. The job of free is adoption, not revenue. If it’s so limited that it never shows the product’s real value, you haven’t built a funnel, you’ve built a frustration machine that teaches people to leave. The Bessemer-cited finding that companies maintaining robust open-source versions see 30% higher adoption exists because of exactly this dynamic.
Gatting developer productivity features is the most common and most damaging pricing mistake in COSS. Gate on organizational context, never on the individual developer’s ability to do good work.
Hiding Enterprise entirely. You don’t have to publish an exact Enterprise number; “custom quote” is standard and fine. But you do have to describe what Enterprise includes and give a clear path to a quote. Mystery packaging reads as something to hide, and developers respond to that with distrust.
Per-seat pricing for infrastructure tools. If value scales with data volume, compute, or resource count rather than team size, seats will mis-price you every time. A team of 5 running 50TB should pay more than a team of 50 running 50MB, and per-seat pricing gets that exactly backwards.
Raising prices without a communication plan. Existing customers on legacy pricing have to be grandfathered or given real runway to adjust. A surprise increase in a COSS context doesn’t stay between you and the affected accounts. It spills into the community as public backlash and reaches far past the customers who were actually repriced.
The first price is always wrong
Your pricing is wrong right now, and that’s fine. The goal is to be wrong in a direction you can learn from fast. Start usage-based or hybrid for infrastructure, seat-based for collaboration. Three or four tiers, no more. A free tier worth running. Enterprise features are gated at the organizational complexity line, not the developer’s desk. Then run the friction test: charge more than feels comfortable, listen for where “we’ll have to think about it” starts, and let the market hand you the clearing price instead of guessing at it.
The COSS companies with the strongest outcomes didn’t get the number right on the first try. GitLab, Confluent, and MongoDB have each surpassed $1B in ARR after many rounds of pricing iteration. The question was never whether the first price was wrong. It’s how fast the second one got less wrong than the first.