DEV Community: Beton

PostHog Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:30 +0000

TL;DR

PostHog started as a product analytics tool and is now 13 products on one bill. ~34.7k GitHub stars, MIT core with a proprietary EE directory, and a per-event price that dropped since the original teardown. The free tier covers 1M events, 5K replays, 1.5K survey responses, error tracking, AI observability, and logs before you pay anything.

Free forever covers 13 product lines — analytics, replays, feature flags, surveys, error tracking, data warehouse, pipelines, AI observability, logs, workflows, and more
Pay-as-you-go starts at $0/month with a credit card; first 1M events each month stay free
Identified-event overages start at $0.000198/event (the 1M–2M tier) and fall to $0.0000010 above 250M; the first 1M events each month are free
Session replay free tier dropped from 15K to 5K recordings — the one free tier that got worse
Platform add-ons (Boost $250/mo, Scale $750/mo, Enterprise $2,000/mo) gate team-size features like SSO, RBAC, and SLAs

This post is a part of series on commercial open source software pricing. See full list of articles here.

PostHog launched as a product analytics alternative to Mixpanel. It's now 13 products on one bill: analytics, session replay, feature flags, A/B testing, surveys, error tracking, a data warehouse, data pipelines, AI observability, logs, workflows, and a PostHog AI assistant. ~34.7k GitHub stars. We use it at Beton for product analytics — PostHog events are the raw material Beton's PQL scoring runs on.

Plans

Free: No credit card. 1 project, 1-year data retention, unlimited team members, community support. Full free-tier allowances across all 13 product lines (see below).
Pay-as-You-Go — from $0/month: Credit card required for overages. Upgrades to 6 projects and 7-year data retention. Email support. Same monthly free allowances as Free; you pay only for usage above them.
Platform Add-Ons: Boost ($250/mo), Scale ($750/mo), Enterprise ($2,000/mo). These gate SSO, RBAC, SLAs, and higher-touch support. Unlike most SaaS vendors, PostHog doesn't force you into a named annual tier — the add-ons are incremental.

Free-tier allowances across all products

The 2026 free tier is broader than the original teardown described. Per month:

Product Analytics: 1M events
Session Replay (standard): 5K recordings
Session Replay (mobile): 2.5K recordings
Feature Flags: 1M requests
Surveys: 1,500 responses
Error Tracking: 100K exceptions
Data Warehouse: 1M rows + unlimited historical syncs
Data Pipelines: 10K events, 1M rows
AI Observability: 100K events
PostHog AI: 2K credits (~$20 value)
Workflows: 10K messages per channel
Logs: 50 GB ingested
Web Analytics: bundled with Product Analytics

For a product with a few thousand monthly active users, this is a real free tier, not a demo.

The event pricing

Product analytics meters identified events (anonymous events are cheaper). The first 1M events each month are free; above that, the per-event rate drops steeply by volume tier:

First 1M events/mo: free
1M–2M: $0.0001980/event
2M–15M: $0.0000697/event
15M–50M: $0.0000360/event
50M–100M: $0.0000146/event
100M–250M: $0.0000037/event
250M+: $0.0000010/event

The marginal rate falls roughly 200x between the first paid band and the 250M+ band. PostHog gets cheap on analytics volume at scale to drive adoption of the higher-margin adjacent products — replays, surveys, pipelines.

A product doing 2M identified events/month pays for the 1M above the free tier at $0.000198 — about $198/month. PostHog's pricing calculator puts 51M identified events/month at ~$3,934/month for product analytics alone. Group-analytics events bill separately, starting around $0.000071/event.

The free tier that got worse

Session replay went from 15K free recordings/month (per the original teardown) to 5K — a 66% cut. Analytics and feature flags stayed flat or expanded; replay was the trade.

The economics explain it. Storing and serving video recordings costs more per unit than counting analytics events. 5K free recordings still covers a product in early traction, but the allowance dropped.

How the 13-product model actually bills

Each product meters independently. Separate free-tier buckets, and overages on one product don't affect another. You can set billing limits per product to cap spend and prevent surprise invoices.

So a team that uses analytics heavily but rarely uses surveys never overpays for surveys. The bundling is additive, not averaging — you pay for what you use, not for what's available.

The downside is complexity. Thirteen billing meters is a lot to track. PostHog's usage dashboard handles it, but modeling your bill in a spreadsheet means knowing your volumes across every dimension, not just events.

License

MIT for the main codebase. The ee directory — enterprise features — ships under a separate proprietary license. PostHog maintains posthog-foss, a FOSS-compliant build that strips the EE directory. Self-hosters who want pure open source use posthog-foss; everyone else uses the main build, where enterprise features stay locked until a license key unlocks them.

A common dual-license pattern (Gitlab and Metabase run variations). Most self-hosted teams use the main build and never touch the EE code. It only matters under a strict OSS policy.

Worth paying for?

The free tier is the most generous in this series. Thirteen products, usage limits, no time restriction. For an early-stage product, PostHog free beats any paid analytics tool.

Pay-as-you-go makes sense once you have product-market fit and want 7-year retention, multiple projects, and email support. A product at 2M identified events/month pays about $198/month for analytics.

The math turns harder at scale. PostHog's calculator puts 51M identified events/month at ~$3,934/month for analytics alone, and session replay — metered separately, per recording — can dwarf analytics costs for a high-traffic consumer app. Still cheaper than Amplitude or Mixpanel at equivalent scale, but not trivial. Model your volumes in PostHog's calculator before committing.

The add-on cliff is real. SSO or an SLA jumps you from $0 to $250–$2,000/month. The pricing page doesn't enumerate the feature boundaries, so you can't tell when you'd need Scale vs. Boost without a sales call.

Beton integrates with PostHog directly — PostHog → Beton turns product events into PQL signals.

How PostHog pricing scales

PostHog meters identified events, and the marginal rate drops ~200× as volume climbs — the first paid million costs $0.000198/event, the band above 250M just $0.0000010. Heavy usage gets progressively cheaper per event.

PostHog's marginal per-event rate by monthly volume tier (log scale). First 1M events free.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is PostHog open source?

MIT for most of the codebase. The ee directory (enterprise edition features) carries a separate proprietary license. PostHog maintains a posthog-foss companion repo that strips all proprietary code for fully FOSS-compliant self-hosting.

What does the free tier actually include?

1M product analytics events, 5K session recordings, 1M feature flag requests, 1.5K survey responses, 100K error tracking exceptions, 1M data warehouse rows, 100K AI observability events, 50 GB logs, and 2K PostHog AI credits — all monthly, all free.

How much does the cheapest paid plan cost?

Technically $0 — Pay-as-You-Go starts at $0/month once you add a credit card; you pay only for usage above the free tier. The first 1M identified events each month are free, and the next 1M (the 1M–2M tier) bills at $0.000198/event — so 2M events/month works out to about $198.

What do the platform add-ons unlock?

Boost ($250/mo), Scale ($750/mo), and Enterprise ($2,000/mo) gate team-oriented features — SSO, advanced RBAC, priority support, SLAs. The specifics aren't fully enumerated on the pricing page; you need to compare tiers directly or contact sales.

How does PostHog pricing compare to Amplitude or Mixpanel?

PostHog is cheaper per event at volume, and the free tier is more generous than Mixpanel's. The key difference is that PostHog bundles session replay, feature flags, surveys, and error tracking in the same account — you're not buying separate tools.

Pricing the Open Source Software, Vol 2

Vlad Nadymov — Wed, 27 May 2026 09:34:26 +0000

TL;DR

Two years after the first round of teardowns, we re-analyzed how 20 commercial open-source tools price — and pulled the 2023 numbers from Wayback to measure the change.

Per-unit prices fell where metering is mature: PostHog's per-event price dropped ~36%, ClickHouse storage ~28%
Appsmith killed hourly billing for a flat, cheaper seat price; ToolJet split one tier into five and added AI credits
The SSO tax hardened — Cal.com moved SSO from its cheapest paid tier up to a pricier one
SSO, RBAC, audit logs, and SLAs gate the top tier almost everywhere, from $9/seat (Twenty) to $25k/year (Grafana)
Strong copyleft (AGPL-3.0) is now nearly as common as MIT; usage-based pricing rivals per-seat

This is the second volume of a running project. The first was a series of pricing teardowns on my personal Substack — read a tool's pricing page line by line, read its license more carefully, decide whether the paid tier is worth it. Two years later I rebuilt the series on the Beton blog, re-verified every current number against the live pricing pages, and pulled the 2023 figures from the Wayback Machine so the comparison is real, not remembered.

This post analyzes what changed across all 20 teardowns. Eight of them have a 2023 baseline; the rest are new to this volume. The raw data — every number with its source — is public on GitHub.

The license is now a sales tool

License across the 20 tools (2026). Strong copyleft (AGPL) is now nearly as common as permissive MIT.

Permissive MIT is still the most common license, but strong copyleft is right behind it. Seven of the twenty ship under AGPL-3.0 — a license that lets anyone read, run, and modify the code, but forces any networked modification to be open-sourced too. That clause makes it legally awkward for a cloud provider to take the project, host it, and resell it without contributing back. AGPL is the open-source answer to "what stops AWS from eating us."

The MIT count also overstates how open these tools really are. PostHog, Infisical, Chatwoot, and others put their core under MIT, then keep enterprise features — SSO, RBAC, audit logs — in a separate directory under a commercial license. The code is open. The features a company needs at scale are not. That open-core split is the dominant monetization pattern in the set.

From seats to usage

Primary pricing model (2026). Usage-based metering now rivals the per-seat model.

The clearest structural change is metering. Usage-based pricing — pay per event, per GB, per run, per credit — used to be a database thing. Now it is everywhere: PostHog meters events, ClickHouse meters compute and storage, Grafana meters five separate signals, Firecrawl and Langfuse and Novu meter credits and runs. Seven of the twenty price primarily on usage, nearly matching the eight that still price per seat.

What two years changed

For every tool that had a published 2023 pricing page — 17 of the 20 — here is the 2023-to-2026 delta. Each 2023 figure is quoted from an archived snapshot of that vendor's pricing page (source links are in the data repo). Langfuse, Firecrawl, and Coolify had no 2023 pricing page and are new to this volume.

Tool	2023	2026	What changed
Appsmith	$0.40/hr per user, capped $20/user-mo	$15/user-mo, flat	Dropped hourly billing for a flat, lower seat price
Cal.com	$12/seat — SSO at Teams	$12/seat — SSO at Organizations ($28)	Price held; SSO moved up a tier
Chatwoot	$19/agent; Enterprise $99	$19/agent; Enterprise $99	Unchanged
ClickHouse	$35.33/TB-mo + $0.2160/unit-hr	$25.30/TB-mo + $0.2181/unit-hr	Storage ~28% cheaper; compute roughly flat
Dify	Pro $59/mo	Pro $59/mo	Price held; AI message-credit bundles formalized
Documenso	$30/mo (Early Adopters, flat)	$25 Individual; $250 Platform	One plan → tiers; $250 Platform is the embed-license escape hatch
Grafana	Cloud Pro $29/mo + usage	Pro $19/mo + usage	Pro minimum dropped $29→$19; now meters five signals
Infisical	$6/dev-mo (Team)	$18/identity-mo (Pro)	Switched to identity-based billing — humans and machines count
Metabase	Cloud Starter $85 (+$5/user); Pro $500	Starter $100 (+$6/user); Pro $575	Base prices up ~15–18%
n8n	Execution-tiered (slider, no static price)	€20/mo Starter	Published a clear Starter price
Novu	Indie Dev $25/mo	Pro $30/mo	$25→$30; still run-metered tiers
Plane	Pro "Coming Soon" (unpriced)	Pro $6/seat	Launched paid pricing at $6/seat
PostHog	$0.00031/event	$0.000198/event (first paid tier)	Per-event price fell ~36%; grew to 13 products
Temporal	1M actions = $25 (pure usage)	Essentials $100/mo	Moved from pure usage to a $100/mo flat floor
ToolJet	Business $24/builder + $8/end-user	Starter $19/builder; AI credits added	Split into five tiers, added AI credits
Twenty CRM	$29/seat (Grow)	$9/seat (Pro)	Cut ~70% per seat, repositioned against Salesforce/HubSpot
Windmill	$10/seat (Team)	Developer $20 / Operator $10 + $50/worker	Split into developer/operator seats plus a compute meter

Compute got cheaper; seats got simpler

The headline most people miss: where metering is mature, the per-unit price went down. Vendors got more efficient and passed some of it on to win adoption.

Unit	2023	2026	Change
PostHog — identified event (first paid tier)	$0.00031	$0.000198	−36%
ClickHouse — storage per TB-month	$35.33	$25.30	−28%
ClickHouse — compute per unit-hour	$0.2160	$0.2181	~flat
Appsmith — seat cap per user-month	$20	$15	−25%

Entry price, 2023 vs 2026, for every tool with a comparable flat/seat price in both years (sorted by 2026 price). Verified against Wayback snapshots. Usage-priced tools (PostHog, ClickHouse) and tools unpriced in 2023 (Plane, Temporal) are excluded.

The flat-rate tools mostly held or nudged up (Metabase +15–18%, Cal.com and Chatwoot flat), while the metered and hourly models came down. The lesson for buyers: on a usage-priced tool, time is on your side — rates trend down as the vendor scales. On a per-seat tool, you pay today's price and it rarely falls.

AI credits: the line item that didn't exist in 2023

None of the 2023 snapshots had an AI credit. By 2026 they are everywhere: ToolJet grants 2,000 AI credits per builder, Dify sells credit bundles, PostHog runs a separate AI-observability meter, and Chatwoot bills its Captain AI assistant at $20 per 1,000 credits. AI features arrived as a metered add-on bolted onto the existing model rather than folded into the base price — a new axis of spend on top of seats and usage. Budget for it separately; it is the easiest line to overlook and the fastest to grow.

Where pricing starts

Cheapest fixed monthly paid tier, 2026, sorted. Most cluster $5–$30; the jump to $59+ is steep. PostHog, ClickHouse, and Grafana are excluded — usage-priced, no fixed entry.

For the tools with a fixed monthly entry tier, most start cheap — between $5 and $30/month, a self-hoster's convenience fee. Above it sits a gap to the $59–$120 tier, where the tool is priced as serious infrastructure. PostHog, ClickHouse, and Grafana don't appear here — they have no fixed entry price, only usage, so a quiet month costs almost nothing and a busy one can cost thousands.

The SSO tax, quantified

The entry price is rarely where the real money is. Single sign-on, SCIM, RBAC, audit logs, and SLAs sit behind a higher tier almost everywhere. Here is the tier you actually have to buy to get SSO, sorted by cost:

Tool	SSO unlocks at	Cost of that tier
Twenty CRM	Pro	$9/seat-mo
Infisical	Pro	$18/identity-mo
Cal.com	Organizations	$28/seat-mo
Chatwoot	Enterprise	$99/agent-mo
PostHog	Boost add-on	$250/mo
Langfuse	Enterprise	$499/mo
Temporal	Enterprise	$500/mo
Metabase	Pro	$575/mo base
Appsmith	Enterprise	$2,500/mo (100 users)
Grafana	Enterprise	$25,000/year commit
ToolJet / n8n / Windmill	Enterprise	custom / contact sales

The spread is enormous — from $9/seat (Twenty CRM treats SSO as table stakes) to a $25,000/year floor (Grafana). And the tax is migrating: Cal.com offered SAML SSO on its cheapest paid Teams tier in 2023; by 2026 it sits one tier up, on Organizations at $28/seat. The feature didn't change. Its price did. If you build on any of these, find out where the SSO line is before a customer's security review forces you across it.

What it means if you're buying

Read the license before the price. AGPL is fine internally; it only bites if you host and resell. The open-core split matters more — check whether the features you need are in the open core or the commercial directory.
On usage-priced tools, expect rates to fall. PostHog and ClickHouse both cut per-unit prices since 2023. Model your real volumes in the vendor's calculator; the headline rate is a ceiling that tends to drop.
Price in the SSO tax early. The jump from a $20/month plan to a $25k/year commit is usually triggered by SSO or compliance, not features. Know where that line is before you build.
Track the AI meter separately. AI credits are a new, easy-to-miss axis of spend. Treat them like any other usage line.

The full series

Every teardown below was re-verified against the vendor's live pricing in 2026.

PostHog — product analytics, usage-metered across 13 products
ClickHouse — columnar database, compute + storage by usage
Metabase — BI, base + per-user, $20k/year enterprise floor
Cal.com — scheduling, MIT, $12/seat Teams
Appsmith — internal tools, hourly billing dropped for $15/user
ToolJet — internal tools, five tiers + AI credits
Chatwoot — support inbox, MIT core + Captain AI credits
Grafana — observability, five usage meters, $25k/year floor
Dify — LLM app platform, modified Apache + credit bundles
Langfuse — LLM observability, MIT core, usage units
Firecrawl — web scraping, credit-based
n8n — workflow automation, per-execution
Windmill — workflow/internal tools, developer/operator split
Temporal — durable execution, $100/month floor
Plane — project management, AGPL, $6/seat
Twenty CRM — CRM, AGPL, $9/seat
Documenso — e-signing, AGPL-3.0
Infisical — secrets management, MIT core + proprietary EE
Novu — notifications, run-metered
Coolify — self-hosted PaaS, $5/month cloud

We build Beton on top of a lot of these. Reading their pricing and licenses closely is part of the job — and the same data-quality discipline goes into the signals we ship.

FAQ

What is a pricing teardown?

A plain-language breakdown of a commercial open-source product's pricing: every plan tier with real numbers, the license analysis (what the open-source version actually lets you do), and a verdict on whether the paid tier is worth it. This series applies the same lens to every tool we cover.

What is this article based on?

The pricing teardowns in this series — each verified against the vendor's live pricing page — plus 2023 figures pulled from Wayback Machine snapshots of those same pages.

How are the 2023 numbers verified?

Each 2023 figure is quoted from an archived snapshot of the vendor's own pricing page from 2023 — not from memory. Tools that existed in 2023 have a baseline; newer ones are flagged as new to this volume rather than guessed.

What changed most since 2023?

Usage-based metering spread beyond databases, AI credits became a standard line item, per-unit prices fell where metering matured, and SSO/compliance features drifted into higher, pricier tiers.

What is the SSO tax?

Putting single sign-on, RBAC, audit logs, and SLAs behind the most expensive tier — so a small team needing SSO for a security review pays enterprise prices to get it.

Appsmith Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:20 +0000

TL;DR

Appsmith is the open-source low-code platform most engineering teams reach for when non-technical people need to edit production data without writing SQL. ~40k GitHub stars, Apache 2.0, and a pricing model that changed materially from the original teardown: hourly billing is gone, replaced by a flat $15/user/month on Business and a $2,500/month entry point on Enterprise.

Free forever — up to 5 cloud users, 3 Git repos, Google SSO, public apps only
Business — $15/user/month, up to 99 users, unlimited repos/envs/workflows, audit logs, custom roles
Enterprise — $2,500/month for 100 users (~$25/user), SAML/OIDC, SCIM, CI/CD, private app embedding
Apache 2.0 on core (no AGPL, no relicensing ambiguity)
Self-hosting removes the user cap entirely; the only gate is commercial features

This post is a part of series on commercial open source software pricing. See full list of articles here.

Appsmith is the low-code platform engineering teams reach for when the ask is "build an admin panel so ops can edit this table without calling an engineer." ~40k GitHub stars, Apache 2.0 core, and a pricing story that changed between the original teardown and today.

The original model charged per hour of usage — $0.40/hour, capped at $20/seat/month. You could model it against session frequency, and the cap kept costs predictable for power users. That model is gone. Appsmith now charges a flat per-user monthly rate: simpler to sell, simpler to budget, and structurally closer to every other SaaS tool in the category.

Plans

Free: Always free. Up to 5 users on cloud, 5 workspaces, 3 Git repos, Google SSO, 3 standard roles, public apps. Community support.
Business — $15/user/month: Everything in Free, plus unlimited workspaces, environments, and Git repos. Workflows, reusable packages, premium integrations, custom roles, audit logs, branding removal. Up to 99 users. Email and chat support.
Enterprise — $2,500/month for 100 users: Everything in Business, plus SAML/OIDC SSO, SCIM provisioning, CI/CD integration, private app embedding, custom integrations, dedicated support with SLAs. Unlimited users beyond the 100-user base.

Self-hosting is a fourth option: community edition, no user cap, no license fee. Commercial features require a paid license even on self-hosted — same tier structure, different delivery.

The billing model shift matters

Hourly billing priced on engagement, not headcount. Ten ops staff who each open one app twice a day paid little. A hundred running heavy sessions paid more, but the $20/seat cap bounded it.

Flat per-user is the opposite logic: headcount determines cost, regardless of session depth. Appsmith apps typically have a small developer team (2-5 people) and a larger consumer population (ops, support, finance) who only read and edit data. Under hourly billing, light consumers were cheap. Under flat per-user, every added workspace member costs $15/month whether they log in daily or once a quarter.

The 5-user free cap is the sharpest version of this: a 6-person cloud team is immediately on paid. At $15/user/month, a 30-person consumer base costs $450/month, or $5,400/year — real money for a non-revenue tooling budget, and a common reason teams push toward self-hosting.

The free tier is narrow

Three Git repos is a real constraint. Past a handful of distinct internal apps, you either consolidate into monolithic apps (bad for maintainability) or upgrade. The original teardown flagged this; it still holds.

The 5-user cloud cap is tight. Any team past a small startup hits it in the first month. Free works as a trial or for small projects, not as a long-term option for an internal tooling program.

The Enterprise gate

Private app embedding — putting internal Appsmith apps inside your existing product or portal — sits behind Enterprise. So does SAML/OIDC SSO. Both are standard requirements above 50 people.

$2,500/month for 100 users is $25/user/month, a $10/user premium over Business. Defensible if SSO and CI/CD save engineering time. But there's no mid-tier between Business at $15/user (capped at 99 users) and Enterprise at $2,500/month. Hit the 99-user ceiling and the next step doubles your per-user cost and is typically billed annually.

License

Apache 2.0 on the core, which is clean. No AGPL ambiguity, no source-available relicensing risk. You can fork, modify, and self-host with no obligation to open-source your changes or pay a license fee.

Commercial features — audit logs, custom SSO, CI/CD, SCIM — are gated to paid plans whether you self-host or use cloud. The license doesn't restrict using the software; it restricts feature access above the community tier.

Apache 2.0 is a genuine open-source license, not a marketing claim. For teams weighing vendor lock-in, this is one of the cleaner postures in low-code.

Worth paying for?

Free is a starting point for projects under 5 users or any team planning to self-host. Self-hosted community edition has no user cap and no license fee — the right default for most organizations with an ops team or a preference for on-premises tools.

Business at $15/user/month is justified when you're on cloud and need Git repos beyond 3, audit logs, or custom roles. Unlimited environments and workflows pay off for teams running internal tooling across multiple stages.

Enterprise at $2,500/month makes sense for strict SSO requirements or a real private-embedding use case — an Appsmith app inside a customer portal, say. At 100 users it's $25/user; per-user cost drops as you add seats beyond that.

The pricing creates friction at the 99-user Business ceiling combined with the annual Enterprise commitment. A 100-person ops team that needs SSO has nothing between $15/user/month and $2,500/month billed annually. That forcing function is why self-hosting stays competitive even for teams that would otherwise be happy on cloud.

How Appsmith pricing scales

Appsmith bills a flat per-user rate, so cost is linear in users — until SSO. SAML lives on Enterprise (~$25/user at 100 users), and below 100 users you still pay the $2,500/month Enterprise floor.

Monthly cost as Appsmith scales by user. Business is flat per-seat; Enterprise (SSO) costs more per seat and starts at a $2,500/mo floor.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Appsmith open source?

Yes. Core Appsmith is Apache 2.0. That means you can fork it, self-host it, modify it, and redistribute it without open-sourcing your changes. There is no AGPL clause to worry about.

What happened to the hourly billing model?

The original model charged $0.40/hour of usage capped at $20/seat/month. As of 2025/2026, Appsmith has moved to a flat per-user monthly rate: $15/user/month on Business, $2,500/month for 100 users on Enterprise. The hourly meter is gone.

What does the free tier include?

Up to 5 users on cloud, 5 workspaces, 3 Git repositories, Google SSO, 3 standard roles, and public apps. Private app embedding is not included. Community support only.

What does Business add over Free?

Unlimited workspaces, environments, and Git repos. Workflows and reusable packages. Premium integrations, custom roles, audit logs, branding removal, and email/chat support. Up to 99 users.

When does Enterprise make sense?

When you need SAML/OIDC SSO, SCIM provisioning, CI/CD integration, or private app embedding — or when you exceed 99 users. Enterprise starts at $2,500/month for 100 users and is typically billed annually.

Can I self-host for free?

Yes, with no user cap. Self-hosting gives you the full community edition. Commercial features (custom SSO, audit logs, etc.) require a Business or Enterprise license even on self-hosted.

Cal.com Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:17 +0000

TL;DR

Cal.com is the open-source Calendly alternative most engineering teams reach for. ~44.6k GitHub stars, MIT licensed (the whole codebase, not a dual-license with a proprietary EE directory), and a seat-based pricing model that stays reasonable up to mid-size teams before handing you off to a custom Enterprise quote.

Free forever — 1 user, unlimited event types, calendar/video connections, 100+ app integrations
Teams: $12/seat/month (billed yearly) — round-robin, routing forms, remove branding
Organizations: $28/seat/month (billed yearly) — SAML SSO, SCIM, SOC 2/HIPAA/ISO 27001, sub-teams
Enterprise: custom pricing — dedicated database, SLA & uptime guarantees, HRIS integrations, priority support
Self-hosting is an MIT-licensed first-class path with no license compliance overhead

This post is a part of series on commercial open source software pricing. See full list of articles here.

Cal.com is the open-source scheduling tool engineers reach for to avoid Calendly's pricing without building a custom booking flow. ~44.6k GitHub stars, MIT licensed, backed by a commercial cloud product with four tiers from free to custom enterprise.

The original Substack teardown covered an earlier version of the pricing. Two things changed since: the per-seat prices are now published as definite numbers, and a new Organizations tier sits between Teams and Enterprise. The star count was 23.6k then — it has nearly doubled.

Plans

Free: Always free. One user. Unlimited event types, calendar and video connections, email and SMS notifications, 100+ app integrations, and payment collection via Stripe or PayPal. The single-user cap is the hard limit — everything else is unlimited.
Teams — $12/seat/month (billed yearly, badged "Save 25%"): 14-day free trial. Adds round-robin scheduling, collective events, team workflows, routing forms, managed event types, and removing Cal.com branding. Fits a scheduling-heavy sales or success team.
Organizations — $28/seat/month (billed yearly, badged "Save 25%"): 14-day free trial. Adds SAML SSO and SCIM provisioning, SOC 2 / HIPAA / ISO 27001 compliance, a company subdomain, domain-wide delegation, unlimited sub-teams, route-by-custom-variable, and role-based permissions. The compliance bundle is the unlock: if your buyers require SOC 2 evidence, you need this tier.
Enterprise — custom pricing: Dedicated database, SLA and uptime guarantees, HRIS and directory integrations, priority support, dedicated onboarding and engineering support. Sales call required.

The seat pricing math

At the Teams tier, a 10-person team is $1,440/year, a 50-person team $7,200/year. That undercuts Calendly's Teams tier ($16/seat/month annual, ~$9,600/year for 50 seats) for comparable features.

Organizations at $28/seat/month pushes a 50-person team to $16,800/year. That's the compliance tax — SAML, SCIM, and the certification stack cost roughly 2.3x the base Teams rate. Worth it only if your sales process requires SOC 2 evidence or enterprise SSO. If it does, there's no alternative tier.

There's no mid-point between Organizations ($28/seat) and Enterprise (custom). The jump to a dedicated database and SLA guarantees goes straight to "talk to sales," so the pricing ceiling is opaque.

The self-hosting case

Cal.com's MIT license makes self-hosting structurally different from most tools in this series. MIT is permissive — run it internally, modify it, embed it in a product, distribute it, with no copyleft obligations or commercial license fees. There's no /ee enterprise directory under a separate proprietary license. No "self-host, but enterprise features need a license key."

The full product, including SSO and compliance tooling, ships under MIT.

So a team that already runs its own infrastructure can deploy Cal.com, configure SAML, and skip the $28/seat/month Organizations tier. The only cost is infrastructure and maintenance time. A 100-person engineering team spending a few hours on deployment and occasional upgrades should self-host. A 5-person startup with no ops capacity should take the cloud tier.

This is the most straightforward self-hosting trade-off in the series — no legal gray areas, no missing features, just infrastructure cost vs. subscription cost.

What the free tier actually covers

The single-user limit is real, but within it the free tier is generous. Unlimited event types means separate booking pages for discovery calls, demos, and customer check-ins without restriction. The 100+ integrations include every major calendar (Google, Outlook, Apple) and video tool (Zoom, Google Meet, Teams). Stripe and PayPal payment collection is included on the free tier — unusual, since most scheduling tools gate payments behind paid plans.

For a solo founder, consultant, or individual contributor, the free tier is a complete product. Upgrading to Teams adds people, not core functionality.

Where the pricing story gets murky

Platform and API pricing — embedding Cal.com scheduling in a third-party product — isn't listed. The enterprise page references an "Enterprise API" and lists "white-label" as an Enterprise feature, but publishes no per-booking or per-seat API rates. This tier targets companies building scheduling into their own products (a CRM vendor wanting a built-in booking flow). Custom quote territory.

The published rates are annual-billed: Cal.com shows Teams ($12/seat/month) and Organizations ($28/seat/month) under a "YEARLY" toggle with a "Save 25%" badge. The badge implies a higher month-to-month rate, but the page surfaces only the annual figures by default, so the monthly numbers aren't quoted here. The annual rates ($12 and $28) run throughout this teardown.

License

The simplest licensing story in this series. No dual-license, no commercial license for enterprise features, no copyleft obligations for self-hosted deployments. Fork it, modify it, ship a product on it — the only requirement is preserving the copyright notice.

The contrast with tools like PostHog or Metabase (proprietary EE directories) matters for teams with strict OSS policies, legal review, or products that embed scheduling. Cal.com clears those reviews cleanly.

Worth paying for?

For a single user: the free tier is a complete product. There's no reason to pay.

For a team under 20 seats that needs round-robin, routing forms, or branding removal: Teams at $12/seat/month is reasonable. The Calendly comparison holds — equivalent features at a lower price from an OSS-backed vendor.

For a team that needs SOC 2 or SSO: Organizations at $28/seat/month is the only cloud option. Self-hosting is the alternative if you have the infrastructure capacity, with no legal friction under MIT.

For teams building scheduling into a product: the white-label and API path requires a conversation. No published pricing.

Self-hosting is the sharpest differentiator here. Most tools in this series carry a self-hosting restriction — a proprietary EE directory, features behind license keys, or an AGPL clause that complicates SaaS embedding. Cal.com has none. If you have infrastructure, the cloud pricing is optional.

How Cal.com pricing scales

Cal.com bills per seat, so cost rises linearly with team size — until you need SSO. SAML lives on Organizations ($28/seat), more than double Teams ($12/seat). A 25-person team pays $300/month on Teams, or $700/month once a security review demands SSO.

Monthly cost as Cal.com scales by seat. The gap between the two lines is the SSO tax.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Cal.com open source?

Yes, MIT licensed — the full codebase under one permissive license. Unlike tools that use a dual-license with a proprietary enterprise directory (e.g. PostHog, GitLab), Cal.com's MIT license lets you self-host, modify, and embed without any copyleft obligations or commercial license purchase.

What does the free tier include?

One user, unlimited event types, unlimited calendar and video connections, email/SMS notifications, 100+ app integrations, and Stripe/PayPal payment collection. The single-user cap is the real limit — you can do a lot as one person before hitting it.

How much is the cheapest paid plan?

Teams starts at $12/seat/month billed annually. A team of 5 is $720/year. There's a 14-day free trial, and Cal.com badges annual billing as 'Save 25%' over monthly.

What does Organizations add over Teams?

Organizations ($28/seat/month) adds SAML SSO, SCIM provisioning, SOC 2 / HIPAA / ISO 27001 compliance, domain-wide delegation, unlimited sub-teams, a company subdomain, and role-based permissions. If you need any compliance certification for enterprise sales, you need Organizations or above.

Is self-hosting a real option?

Yes, and it's the clearest self-hosting story in this series. MIT license means no copyleft, no commercial license requirement, no locked enterprise features. You get the full product. The tradeoff is infrastructure maintenance — but for a team that already runs its own stack, it's a straight cost calculation.

Chatwoot Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:15 +0000

TL;DR

Chatwoot is the open-source shared inbox most support teams reach for when they want out of Intercom pricing. ~29.7k GitHub stars, MIT for most of the codebase — but the enterprise/ directory ships under a separate source-available commercial license that requires a paid subscription to run in production. The pricing is per-agent/month with four cloud tiers, plus a self-hosted path that mirrors the same tiers. Captain AI ships credit bundles into Startups and above.

Hacker (free forever) — 2 agents max, 500 conversations/month, 30-day data retention, no Captain AI
Startups — $19/agent/month (annual), unlimited conversations, 300 Captain AI credits/month
Business — $39/agent/month (annual), 500 Captain AI credits/month, teams + automations
Enterprise — $99/agent/month (annual), SSO/SAML, audit logs, video/voice support, 800 Captain AI credits/month
Captain AI overages: $20 per 1,000 credits beyond your plan's monthly allowance
MIT core + separate commercial EE license — the enterprise directory is source-available but not open source

This post is a part of series on commercial open source software pricing. See full list of articles here.

Chatwoot is the open-source alternative to Intercom, Zendesk, and Salesforce Service Cloud — a shared inbox for live chat, email, social, and messaging from one interface. ~29.7k GitHub stars: meaningfully adopted, not just starred. The latest release (v4.14.0, May 2026) ships the Captain AI agent as a first-class feature.

Plans

Hacker — free: 2 agents, 500 conversations/month, 30-day data retention, live chat only. No Captain AI. No email or social channels.
Startups — $19/agent/month (annual): Unlimited conversations, all channels, 1-year data retention, 300 Captain AI credits/month, live chat and priority email support.
Business — $39/agent/month (annual): Everything in Startups plus teams, automation rules, custom attributes, pre-chat forms, campaigns, 500 Captain AI credits/month, 2-year data retention.
Enterprise — $99/agent/month (annual): SSO/SAML, audit logs, agent capacity management, video and voice support (20+ agents), dedicated account manager (20+ agents), 800 Captain AI credits/month, 3-year data retention.

Self-hosted Community is free with the MIT core and no agent cap. Two paid self-hosted tiers mirror the cloud headline prices: Premium Support at $19/agent/month (adds Captain AI, voice calls, custom branding, agent capacity, roles/permissions, priority support) and Enterprise at $99/agent/month (adds SSO/SAML and SLA). You buy the license and support, not the infrastructure.

The free tier is narrow

500 conversations per month is about 17 a day. Live chat only — no email routing, no WhatsApp, no social. The 2-agent cap makes it a solo or duo test environment, not a tier.

Intercom and Zendesk restrict their free tiers similarly. Hacker exists to evaluate the product, not run support on it. Past a couple hundred conversations a day, you're on Startups at minimum.

Captain AI: the credit question

Captain is four things: an AI assistant that handles initial inquiries from your help center and past conversations, a co-pilot that drafts responses for human agents, FAQ gap detection, and conversation memory. The co-pilot is the reason most teams will consider it.

Each paid plan includes a monthly credit bundle — 300 on Startups, 500 on Business, 800 on Enterprise. Overages run $20 per 1,000 credits. Chatwoot doesn't publish a per-interaction credit cost, so you can't model your bill in advance without usage data. This is the murkiest part of the pricing.

Captain is included in every paid tier, not a separate add-on. Intercom's Fin AI bills per resolution on top of seat costs — a meaningful structural difference.

The per-seat math

Seat-based pricing is straightforward to model. A 10-person support team:

Startups: $190/month (annual)
Business: $390/month (annual)
Enterprise: $990/month (annual)

Startups to Business is $200/month for 10 seats. You buy teams (routing by skill or shift), automation rules, custom attributes, and pre-chat forms. Past basic volume, automations alone justify it.

Business to Enterprise is $600/month for 10 seats. The gated items are SSO/SAML and audit logs — compliance requirements at enterprise companies, not nice-to-haves. If IT security requires centralized identity, you pay Enterprise whether you want the rest of the tier or not.

MIT core vs. commercial EE: the actual split

This is the part that matters for self-hosted teams.

Chatwoot's LICENSE file is MIT for the main codebase. The carve-out: everything under the enterprise/ directory ships under a separate enterprise/LICENSE — commercial and source-available, not open source. Production use requires a valid enterprise subscription and active agreement with Chatwoot Inc. Modification for development and testing is allowed; production modification is not without a subscription. Chatwoot retains IP rights on modifications.

In practice: SSO/SAML, audit logs, agent capacity management, and custom branding live in the enterprise directory. The MIT core covers all channels, automations, help center, custom attributes, and reporting. Captain AI is gated separately — it ships with cloud paid tiers and self-hosted Premium Support and above, not with the free Community edition. Most teams self-hosting for cost reasons never hit the enterprise directory.

This dual-license pattern — MIT core plus commercial EE directory — is common across OSS SaaS: PostHog, GitLab, and Metabase all use variants. The practical risk is accidental production use of enterprise code. The full Docker image includes the enterprise code; if your install exposes an SSO login page, you're running enterprise code and should have a subscription. Most teams don't worry about this unless they're large enough for a lawyer to notice — but it's worth knowing what you run.

License

MIT for the main codebase, including most product features and all channels. The enterprise/ directory ships under a separate commercial source-available license — production use requires a Chatwoot Enterprise subscription. Self-hosted Community (MIT only) is genuinely free with no agent limit; self-hosted Enterprise costs the same $99/agent/month as cloud Enterprise.

The MIT core is wide enough that most support teams never touch the enterprise directory. The commercial license matters only when you need SSO, audit logs, or agent capacity management.

Worth paying for?

Replacing Intercom or Zendesk Suite — both materially higher per-seat before AI add-ons — Chatwoot Startups at $19/seat is a significant cost cut. Channel support is comparable: email, WhatsApp, Facebook, Instagram, Telegram, SMS, TikTok, API. Captain AI credits ship in every paid tier; Intercom's Fin AI charges per resolution on top of seat costs.

The free Hacker tier is not a real option for production support. Past a few hundred conversations a day, the choice is Startups vs. Business, not free vs. paid.

Self-hosted Community is the strongest free option in the category — no agent cap, full MIT core, production-ready. The trade: you own the infrastructure and get no Captain AI, which on self-hosted starts at Premium Support ($19/agent/month).

Enterprise at $99/seat fits compliance-driven buyers who need SSO and audit logs. The Business-to-Enterprise gap is real, but if IT controls identity providers, you were never staying on Business.

How Chatwoot pricing scales

Chatwoot bills per agent. The Startups tier ($19/agent) scales cheaply, but SSO/SAML only appears on Enterprise ($99/agent) — a 5× jump per seat for the same headcount.

Monthly cost as Chatwoot scales by agent. SSO forces the Enterprise tier at 5× the per-agent rate.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Chatwoot open source?

Most of it is MIT. The enterprise/ directory ships under a separate commercial license — source-available, but production use requires a paid subscription and active agreement with Chatwoot Inc. The MIT core covers most of the product; SSO, audit logs, agent capacity management, and custom branding sit in the enterprise directory. Captain AI is gated to paid tiers, not bundled with the free Community edition.

What does the free tier actually give you?

2 agents, 500 conversations per month, 30-day data retention, live chat only (no email, social, or messaging channels). No Captain AI credits. Usable for a very small team testing the product; not usable for a real support operation.

How much is the cheapest paid plan?

Startups at $19/agent/month billed annually. A 5-person support team pays $95/month. Includes unlimited conversations, all channels (email, social, WhatsApp, Telegram, SMS, TikTok, Facebook, Instagram), 1-year data retention, and 300 Captain AI credits per month.

What is Captain AI and how does the credit system work?

Captain is Chatwoot's AI layer — an AI assistant that handles initial inquiries from a help center/FAQ knowledge base, a co-pilot that suggests responses to human agents, smart FAQ gap detection, and conversation memory across sessions. Plans include a monthly credit bundle (300 on Startups, 500 on Business, 800 on Enterprise). Overages cost $20 per 1,000 additional credits.

Does self-hosted Chatwoot cost the same as cloud?

The Community edition is free to self-host with no seat limits, but it has no Captain AI, voice calls, custom branding, agent capacity, roles/permissions, SSO/SAML, or SLA. Self-hosted also offers two paid tiers: Premium Support at $19/agent/month (adds Captain AI, voice, branding, agent capacity, roles/permissions, priority support) and Enterprise at $99/agent/month (adds SSO/SAML and SLA) — the same headline prices as the equivalent cloud plans. You're paying for the license and support, not the hosting.

ClickHouse Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:12 +0000

TL;DR

ClickHouse is a column-oriented OLAP database built for real-time analytical queries at scale. Originally developed at Yandex, it spun out as an independent company that raised $300M at a $2B valuation. ~47.6k GitHub stars, Apache 2.0 core, and a managed cloud with three tiers and no permanent free tier.

No permanent free tier — ClickHouse Cloud offers a 30-day trial only ($300 in credits)
Usage-based: storage is $25.30 per 1 TB/month on every tier; compute runs $0.2181/$0.2985/$0.3903 per unit-hour on Basic/Scale/Enterprise
Worked example: a small Basic service (6h/day) is ~$66.52/month; running it 24/7 is ~$186/month
Scale example bills start at $499.38/month (multi-replica, auto-scaling, private networking)
Enterprise example bills run ~$2,669 to ~$9,714/month — custom configs, HIPAA/PCI, SAML/SSO, CMEK
Self-hosting on Apache 2.0 is a genuine alternative — anyone who can run a Docker container can skip Cloud entirely

This post is a part of series on commercial open source software pricing. See full list of articles here.

ClickHouse is a column-oriented analytical database built for queries that bring a transactional database to its knees — billions of rows, sub-second aggregations, millions of events per second. Yandex built it for Metrica, their web analytics product, and open-sourced it in 2016. The company that formed around it raised $300M at a $2B valuation. At ~47.6k GitHub stars, it's an infrastructure default in the OSS database world.

Website: clickhouse.com
Pricing: clickhouse.com/pricing
GitHub: github.com/ClickHouse/ClickHouse

Plans

ClickHouse Cloud runs three tiers on AWS, GCP, and Azure. Compute and storage bill separately, metered per minute in 8 GiB RAM increments. The dollar figures below are ClickHouse's own worked examples from the docs (AWS us-east-1) — specific replica, storage, backup, and egress configs bundled into one monthly total. They are illustrative, not floor prices. The real floor is the per-unit rate: $25.30/month of storage plus the compute you consume.

Basic — example bill $66.52/month: ClickHouse's worked example puts a small service at $66.52/month, assuming 6 hours of activity per day (1 replica, 8 GiB RAM, 2 vCPU, 500 GB compressed data + 500 GB backup). The same config runs $106.44 at 12h/day and $186.27 at 24h/day. Daily backups, 1-day retention. Single-zone only. Storage capped at 1 TB per service. 8–12 GiB total memory, not configurable.
Scale — example bill from $499.38/month: 2+ replicas across multiple availability zones. Unlimited storage. Automatic vertical scaling, manual horizontal scaling. Compute-compute separation. Configurable backup schedule and retention. Private networking and S3 role-based access. Higher per-unit compute rate ($0.2985/unit/hr). The published examples run $499.38, $986.92, and $1,474.47/month by replica size.
Enterprise — example bills from $2,669/month: High-memory configs and large storage at the highest compute rate ($0.3903/unit/hr). The published examples range from $2,669.40/month (5 TB) to $9,713.79/month (20 TB). SAML/SSO, private regions, transparent data encryption / CMEK, HIPAA and PCI compliance, scheduled upgrades, named lead support engineer. Contact-sales tier; starting prices vary.

Storage bills the same across all three tiers at $25.30 per 1 TB/month (varies by region and cloud provider). The compute rate climbs with the tier: $0.2181/unit/hr on Basic, $0.2985 on Scale, $0.3903 on Enterprise, metered per minute in 8 GiB RAM increments. Data transfer bills separately — public internet egress from $0.1152/GB, inter-region egress from $0.0312/GB. ClickPipes (managed ingestion) adds $0.04/GB ingested plus $0.20/hr per compute unit.

There is no permanent free tier. ClickHouse Cloud offers a 30-day trial with $300 in credits.

The self-hosting math

It's hard to imagine a team that needs ClickHouse at scale but lacks someone who can run a Docker container.

The Apache 2.0 license puts no commercial restrictions on self-hosting. ClickHouse runs on a single server for development and scales to a cluster for production, with official Docker images and Kubernetes Helm charts. A 16 GiB cloud VM costs roughly $80–150/month by provider and region — comparable to Basic, but without the 1 TB storage cap and with full config control.

The case for Cloud is operational burden, not capability. No infrastructure engineers and you want zero cluster maintenance? Cloud removes real work. If someone can manage a Postgres server, they can manage ClickHouse — and Apache 2.0 means you're not paying for that capability.

The ~7.5x gap between Basic and Scale

ClickHouse's example bills put a small Basic service around $66/month and the entry Scale service at $499/month — a ~7.5x jump. The per-unit rates barely differ ($0.2181 vs $0.2985 per compute unit/hour), so the gap is bigger configs and more replicas, not a rate hike. What you buy: multi-zone redundancy, auto-scaling, compute-compute separation, private networking, configurable backups.

For production, the Basic limits matter. Single-zone means no high availability. The 1 TB storage cap is low for a database sold as "analytics at scale." Manual-only scaling means sizing for peak — overprovisioning or scrambling during spikes.

Basic is a development or staging environment, not a production tier. The real choice is Scale vs. self-hosting, and Scale's ~$500/month is the threshold where self-hosting starts looking attractive.

Compute + storage separation

ClickHouse Cloud separates compute and storage billing — the right model for an OLAP database. Storage grows predictably; compute scales down to zero when idle (Scale and Enterprise). You don't pay for compute when no queries run — useful for clear peak/off-peak patterns.

Basic benefits less cleanly. Its example bill assumes 6 hours of activity per day, so the $66.52 figure bakes in significant idle time. Running Basic continuously costs $186.27/month — nearly 3x the headline.

License

Apache 2.0 for the core ClickHouse database. No BSL restrictions, no open-core commercial license on the engine. ClickHouse Cloud is a separate product built on top, billed separately. The database you'd self-host is the same one powering Cloud — no feature-gating between the open-source build and the managed service, only the operational layer differs.

That sets ClickHouse apart from tools that keep their best features proprietary. The columnar engine, query optimizer, and integrations are all Apache 2.0. You pay Cloud for infrastructure operations, not feature access.

Worth paying for?

ClickHouse Cloud makes sense for teams that need real-time OLAP without managing a cluster — and will pay $499/month or more for Scale, the first production-grade tier. Basic is a staging environment with a storage cap; the $66/month headline doesn't change that.

For teams with any infrastructure capability, self-hosting is the answer. Apache 2.0, no commercial restrictions, runs on any cloud or on-prem. 47.6k GitHub stars and an active community mean solid documentation, maintained packages, and real answers in forums.

Enterprise requires a sales conversation, sized for large data volumes (examples start at 5 TB) with compliance needs. At that scale, you already know whether Cloud Enterprise or a managed cluster on your own infrastructure fits better.

How ClickHouse pricing scales

ClickHouse Cloud meters storage at a flat $25.30 per TB-month (compute is billed separately by usage), so the storage component of the bill scales linearly with data volume.

ClickHouse storage cost by volume ($25.30/TB-month). Compute is metered separately on top.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is ClickHouse open source?

Yes. The core ClickHouse database is Apache 2.0. ClickHouse Cloud is a separate managed service with its own billing. There are no BSL or open-core license restrictions on the core engine — you can self-host without commercial restrictions.

Is there a free tier on ClickHouse Cloud?

No permanent free tier. ClickHouse Cloud offers a 30-day trial with $300 in credits, but after the trial you must pick a paid plan or self-host. Basic's published rates are $25.30 per 1 TB/month storage plus $0.2181 per compute unit/hour; a realistic small Basic service works out to about $66.52/month in ClickHouse's own example.

What does the cheapest paid plan include?

Basic bills storage at $25.30 per 1 TB/month and compute at $0.2181 per unit/hour. ClickHouse's worked example puts a small service at $66.52/month, but that assumes only 6 hours of activity per day (1 replica, 8 GiB RAM, 2 vCPU, 500 GB compressed storage, 500 GB backup, daily backups with 1-day retention). Run it 24/7 and the same config is $186.27/month. Single-zone only — no high availability. Storage is capped at 1 TB per service.

What does Scale add over Basic?

Scale's example bills start at $499.38/month. It adds multi-replica deployments across 2+ availability zones, automatic vertical scaling and manual horizontal scaling, compute-compute separation, configurable backups, private networking, and S3 role-based access. Unlimited storage instead of Basic's 1 TB cap, and a higher compute rate ($0.2985 vs $0.2181 per unit/hour).

Why would someone pay for Cloud over self-hosting?

Operational simplicity: no cluster management, no hardware provisioning, automatic scaling, managed backups. For teams without dedicated infrastructure engineers, that's worth paying for. For teams that have someone who can manage a cluster, the Apache 2.0 license makes self-hosting a legitimate cost control option.

Coolify Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:09 +0000

TL;DR

Coolify is an open-source, self-hostable PaaS — 52,600+ GitHub stars, Apache-2.0 licensed, with exactly two tiers. Self-hosted is free forever with the full feature set; Cloud is $5/month base for a managed Coolify dashboard that deploys to your own servers.

Apache-2.0 across the board — no enterprise edition, no feature gating, no AGPL/BSL trap
Self-hosted free forever: unlimited servers, deployments, and team members
Cloud at $5/month (or $4/month annual) includes 2 connected servers; +$3/month per extra server
"Bring your own servers" model — you pay for the control plane, your apps run on Hetzner/DO/AWS/Pi
Built by a solo founder (Andras Bacsai) with 3,400+ cloud customers; roughly $17k–30k MRR

Hey, it's Vlad, founder of Beton.

Coolify is the open source project I wish existed when I was setting up my first VPS five years ago. It's a self-hosted PaaS that replaces Heroku, Vercel, and Netlify — and the pricing model is unlike anything else in the space.

How Coolify pricing scales

Coolify barely scales by price: self-hosting is free forever, and Cloud is a flat $5/month convenience fee (+$3/month per extra server beyond two).

Coolify pricing by tier. The feature set is identical; Cloud is a flat convenience fee.

This post is a part of series on commercial open source software pricing.

What is Coolify

Coolify is an open-source, self-hostable platform-as-a-service. You install it on any server with SSH access and it gives you a dashboard to deploy applications, databases, and 280+ one-click services. Think of it as your own private Heroku.

It supports any language, any framework, any server. VPS, Raspberry Pi, EC2, bare metal — doesn't matter. All you need is SSH.

52,600+ GitHub stars
Apache-2.0 license
Built with PHP (Laravel) + Svelte
3,400+ cloud customers
Solo founder project (Andras Bacsai), built largely in public via live streams

The tagline is "self-hosting with superpowers" and it's accurate. This isn't a toy — it handles SSL, reverse proxying, Docker orchestration, git-based deployments, database provisioning, and monitoring.

The licensing play

Apache-2.0. That's it.

No AGPL trap, no BSL time-bomb, no "sustainable use" restriction. You can fork Coolify, modify it, embed it in a commercial product, and sell it. The most permissive license in serious open source.

This is a deliberate philosophical choice. From their own philosophy page: "We've seen too many promising open-source projects slowly close their doors, adding 'enterprise' features and artificial limitations. We chose a different path."

And they mean it. There is no enterprise edition. There are no features behind a paywall. The self-hosted version is the full product. Cloud and self-hosted share the exact same open-source codebase.

This is rare. Most COSS companies use licensing as a monetization lever — AGPL to prevent competitors from forking (Firecrawl), BSL to block hosted competition (Sentry), or custom licenses to restrict commercial use (n8n). Coolify does none of that.

The bet is pure: make the product good enough that people will pay for convenience even when the free version is identical.

Pricing structure

Coolify has exactly two tiers. That's it. No confusing grid of plans.

Self-hosted — Free forever

Full access to every feature
Unlimited servers, unlimited deployments, unlimited team members
Community support (19k+ Discord members)
Automated or self-managed updates
All future features included

Cloud — $5/month base (monthly) or $4/month (annual)

Base price includes 2 connected servers
+$3/month per additional server (monthly) or +$2.70/month (annual)
Connect unlimited servers total
Unlimited deployments per server
Free email alerts for Coolify events
Community + limited email support
Founder-tested updates before they reach you

Annual billing saves 20%.

That's the entire pricing page. No per-seat fees. No execution limits. No credit system. No hidden add-ons.

The "bring your own servers" model

Here's what makes Coolify weird compared to every other PaaS.

Render, Railway, Fly.io — they sell you compute. You pay them, they run your containers on their infrastructure. Coolify Cloud flips this completely: you pay $5/month for managed Coolify, but your applications run on YOUR servers. Hetzner, DigitalOcean, AWS, your Raspberry Pi — whatever you want.

You're not buying hosting. You're buying "someone else runs the Coolify dashboard for me."

This is less "cloud PaaS" and more "Coolify-as-a-service." Your servers, their control plane.

It's a smart model for the target user: someone technical enough to have a Hetzner box (starting at ~$4/month for a decent VPS) but who doesn't want to babysit a self-hosted dashboard. You get the economics of cheap European VPS + the convenience of not managing the orchestration layer.

The FAQ confirms it: "You need to bring your own servers from any cloud provider. Your apps will be deployed on the server you connect to the cloud, while Coolify runs on our managed server."

Does it make sense to pay?

Let's do the math.

Solo developer, 2 servers: $5/month cloud. That's less than a single Render hobby service. You get a managed dashboard, email alerts, and tested updates. The alternative is self-hosting Coolify on one of your servers, which takes about 60 seconds to install but means you're responsible for keeping it updated and backed up.

Small startup, 8 servers: $5 + (6 x $3) = $23/month. No per-seat fees — your whole team deploys through the same instance. Compare that to Railway or Render where 8 services could easily cost $100-200+/month just in platform fees, before compute.

Larger team, 20 servers: $5 + (18 x $3) = $59/month. Still under $60. With unlimited team members. This is where the model gets absurd — you could have 50 engineers deploying through Coolify and it costs the same.

The catch: there are no per-seat fees, but each additional team (workspace) in the cloud requires a separate subscription. If you need isolated environments with separate billing, that adds up. For most companies, one team is enough.

The honest answer: if you're comfortable managing a VPS, self-host Coolify for free. It takes one curl command to install and the feature set is identical. Cloud at $5/month is a convenience fee, not a feature upgrade. The only reason to pay is that you genuinely don't want to maintain the Coolify instance itself — the updates, the backups, the occasional troubleshooting.

I'd pay it. Not because I need to, but because $5/month is below my "think about it" threshold and I'd rather spend that 15 minutes per month on something else.

The bigger picture

Coolify's monetization strategy is the anti-pattern to modern COSS. No feature gating, no license restrictions, no enterprise upsell. Just Apache-2.0 everything and charge a nominal convenience fee for hosted management.

Can this sustain a business? With 3,400+ cloud customers at $5+/month, that's roughly $17k-30k MRR depending on server counts. Add sponsorships (they have a long list of sponsors including Hetzner and Hostinger) and it's a viable solo founder operation.

But it's not a venture-scale business — and I think that's the point. Coolify isn't trying to be the next $100M ARR company. It's trying to be the best self-hosting platform in the world and let the economics follow.

For users, this is the dream scenario. A genuinely free, genuinely full-featured product with an optional convenience tier that costs less than a coffee. No rug-pull risk because Apache-2.0 means the community can fork it if the project ever changes direction.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Coolify open source?

Yes — Apache-2.0 for the entire product. There is no enterprise edition and no features behind a paywall; the self-hosted version is identical to what Cloud runs.

What's the cheapest paid Coolify plan?

$5/month on monthly billing, or $4/month effective on annual (20% savings). The base price includes 2 connected servers and unlimited deployments.

Do my apps run on Coolify's servers if I use Cloud?

No. Coolify Cloud runs the managed dashboard on their infrastructure, but your applications deploy to servers you bring — Hetzner, DigitalOcean, AWS, bare metal, even a Raspberry Pi.

When does it make sense to pay for Coolify Cloud?

When you don't want to maintain the Coolify instance itself. The feature set is identical to self-hosted, so $5/month is a convenience fee for updates, backups, and not babysitting the dashboard.

Dify Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:06 +0000

TL;DR

Dify is the most-starred open source AI agent platform on GitHub — 139k stars, modified Apache 2.0 license, cloud from $0 to $159/month plus an Enterprise tier. The headline is "Apache 2.0," but a multi-tenant restriction makes it functionally a Sustainable Use license for anyone trying to resell it.

Sandbox is a 200-credit lifetime demo, not a real free tier.
Pro at $59/month (5k credits, 3 seats) is the right starting point for solo devs and 2–3 person teams.
Team at $159/month unlocks 50 seats, unlimited triggers, and the Langfuse/Langsmith integration — the standard play for growing AI-native startups.
Message credits meter underlying model calls, not user messages — budget 3–5x what you'd naively expect.
Self-hosting Community Edition is fine for internal use; embedding Dify in a SaaS you sell requires a commercial license from LangGenius.

Hey, it's Vlad, founder of Beton.

Dify is the most-starred AI agent platform on GitHub. 139k stars, growing fast, and basically every team building an LLM-powered product has at least clicked through their docs. They sit somewhere between a no-code workflow builder and a full agentic backend — RAG pipelines, prompt management, tool calls, MCP integrations, chat UIs, the whole stack in a single Docker compose.

What's interesting from a pricing standpoint isn't the cloud tiers. It's the license. Dify ships under "modified Apache 2.0" — which sounds friendly, until you read the modification.

How Dify pricing scales

Dify scales in flat tiers, gated mostly by seats, apps, and message credits rather than usage volume.

Dify pricing by tier (Enterprise is custom).

This post is a part of series on commercial open source software pricing.

What is Dify

Dify is an open source platform for building production-ready AI applications. You drag nodes together to wire up agents, connect knowledge bases, plug in models, expose the result as a chatbot or an API, and ship.

The pitch is "Vercel for AI agents" — a single platform that handles the boring parts (model routing, RAG pipelines, observability, multi-LLM support, deployment) so you can focus on the prompts and tools. It supports OpenAI, Anthropic, Llama, Azure OpenAI, Hugging Face, Replicate, plus local models via Ollama.

Website: dify.ai
Pricing: dify.ai/pricing
GitHub: github.com/langgenius/dify — 139,400+ stars, 21,800+ forks
License: modified Apache 2.0 (the modification matters — see below)
Backed by: not officially disclosed, but it's a LangGenius Inc. product, Chinese-origin, with significant enterprise traction in APAC

For context: 139k stars puts Dify well ahead of n8n (180k but a much older project), Langfuse (~24k), and Flowise (~30k). It's the de-facto leader in the "open source AI agent platform" category by raw popularity.

The licensing play

This is where Dify gets genuinely interesting — and where most readers stop reading the license.

The repo says "Apache 2.0" at the top, and most engineers will see that and assume permissive paradise. It's not. It's Apache 2.0 with two extra clauses bolted on, and one of them is the entire game.

Clause 1 — no multi-tenant use without permission:

"Unless explicitly authorized by Dify in writing, you may not use the Dify source code to operate a multi-tenant environment. Tenant Definition: Within the context of Dify, one tenant corresponds to one workspace."

In plain English: you can self-host Dify for your own company. You cannot stand up a Dify instance and let multiple paying customers share it as a service. If you wanted to wrap Dify in a SaaS skin and resell agentic workflows to your customers — the business that Dify itself is in — you need a commercial license from LangGenius.

This is functionally a "Sustainable Use" clause stapled onto Apache 2.0. Same intent as Elastic's SSPL or Sentry's BSL: the upstream vendor reserves the right to be the only one making money from operating the software at scale.

Clause 2 — you can't remove the Dify logo:

"You may not remove or modify the LOGO or copyright information in the Dify console or applications."

If you self-host and want to white-label the UI for your team, you're technically violating the license. For internal use this is mostly nuisance-level. For anyone embedding Dify in a product, this is a deal-breaker without a commercial agreement.

What this actually means for the reader:

Self-hosting for internal use at one company: totally fine. Spin up Docker, build agents for your team, no payment required. Unlimited workspaces effectively, because the multi-tenant clause only triggers when you serve external customers.
Building a product on top of Dify for your customers: you need a commercial license. Not optional. Same situation as building a managed Sentry service or a managed Elastic.
Forking Dify into your own competing platform: technically allowed under Apache 2.0 base, but the multi-tenant clause kicks in the moment you operate it. Practically: don't.

This isn't bad faith. It's the standard COSS playbook — give the product away to maximize bottom-up adoption, monetize the SaaS layer, prevent AWS-style strip-mining. But calling it "Apache 2.0" is borderline misleading. It's Apache 2.0 in the same way the Sustainable Use License is "MIT-flavored." The name on the tin doesn't tell you the rules.

Pricing structure

Dify Cloud is priced per workspace per month. The billable unit is message credits, which roughly correspond to one round-trip LLM call.

Cloud plans:

Sandbox (free) — 200 message credits total (not per month — total to try the product), 1 workspace, 1 user, 5 apps, 50 knowledge documents, 50MB knowledge storage, 30-day log history, 5,000 API calls/month. No credit card required.
Professional — $59/month ($590/year, 17% off) — 5,000 message credits/month, 1 workspace, 3 team members, 50 apps, 500 knowledge documents, 5GB knowledge storage, 20,000 trigger events/month, unlimited log history, no Dify API rate limit, priority email support.
Team — $159/month ($1,590/year) — 10,000 message credits/month, 1 workspace, 50 team members, 200 apps, 1,000 knowledge documents, 20GB knowledge storage, unlimited triggers, top-priority document processing, advanced analytics integrations (Langsmith/Langfuse), priority email support.
Enterprise — talk to sales — Self-hosted or dedicated cloud, SOC2 Type II report, role management, WebApp branding customization (i.e. the only way to legally remove the logo), unlimited everything, support SLA.

Self-hosted plans:

Community Edition (free) — modified Apache 2.0. Self-host on your infra. All core features for internal use. Ungated except for the multi-tenant restriction.
Enterprise (self-hosted) — custom pricing. Includes commercial license, audit logs, fine-grained RBAC, SSO/SCIM, branding removal, SLA, dedicated support.

Free for verified students and educators (their education program covers the Pro tier).

The message credit math

The credit system is where the real cost story lives. Dify defines a "message credit" as roughly one LLM completion — a chatbot reply, an agent step, a workflow execution that calls a model. That's intentionally vague because the actual consumption depends on which model you wired in.

5,000 credits/month on Pro sounds like a lot until you realize what an agent actually does. A single user conversation with a multi-step agent might burn 5–15 credits — one for the planner, several for tool calls, one for the synthesizer. A RAG-backed support bot answering 100 customer questions a day at 5 credits each = 15,000 credits/month. You're already off Pro and into Team territory, or buying overage (which exists but isn't priced publicly on the page — you have to ask sales).

This is the standard agent-pricing trap. Per-message billing looks cheap on the surface because the user thinks in "messages I send" but the platform meters "model calls under the hood." The two numbers diverge by 3-10x for any non-trivial agent.

The Team plan at $159/month with 10k credits/month works out to roughly $0.016 per credit. If your average agent burn is 5 credits per user interaction, you're paying ~$0.08 per interaction in platform fees, on top of whatever you pay OpenAI or Anthropic for the actual model.

For a team running their own production AI feature with even modest volume, the credit ceiling on Pro and Team will be the binding constraint long before any other limit. Plan accordingly, or self-host.

The pricing cliff

Sandbox to Pro: 200 lifetime credits to 5,000/month. This isn't really a cliff, it's the on-ramp. Sandbox is a glorified demo — you can't realistically build anything past a hello-world.

Pro ($59) to Team ($159) is a 2.7x price jump for a 2x increase in message credits. What you're really buying with that extra $100/month:

47 more team members (3 → 50). For most early teams, the seat cap on Pro is the actual binding constraint. The moment you have an engineering team, a PM, and a couple of analysts wanting to view logs, you're upgrading.
4x knowledge storage (5GB → 20GB) and 2x documents (500 → 1,000). Matters for RAG-heavy use cases. Doesn't matter at all for pure agent/workflow use cases.
Unlimited triggers (vs. 20k/month on Pro). If you're running scheduled workflows or webhook-triggered agents at any volume, this matters fast.
Top-priority document processing. Dify's vector indexing has a queue. On Pro you wait. On Team you don't. Realistic impact: 30 seconds vs. 5 minutes when you upload a knowledge base.
Advanced analytics integrations with Langsmith/Langfuse. If you're already running Langfuse (which you should be — see my Langfuse teardown), this is the integration that pipes your Dify trace data into your real observability stack.

For solo developers and 2-person teams, Pro is enough. The seat cap forces the upgrade once you have any kind of cross-functional team.

The bigger cliff is Team to Enterprise. The page doesn't show a price. From conversations and public discussions, Dify Enterprise self-hosted licenses start at five figures annually, scaling with usage. That's the SaaS license you're buying when you actually want to wrap Dify in your own product — at which point you're paying not just for support and SLA, but for the right to operate the thing commercially at all.

Self-hosted vs. cloud

The self-hosted option is genuinely viable for internal use. Docker compose gets you running in 5 minutes. Helm chart for production Kubernetes. The community edition has functionally all the features — model providers, agent flows, RAG, MCP integrations, the whole thing.

The catch is operating it. Dify's stack includes PostgreSQL, Redis, a vector database (Weaviate/Qdrant/Milvus depending on config), a worker queue, the API, the web frontend. That's six containers minimum, and at production scale you're managing all of them. The vector DB is the painful one — Qdrant is fine until your knowledge base hits real volume, then you're tuning sharding.

For a single team with a few internal AI tools, self-hosting saves you the $59-$159/month and gives you full control of your data. For anyone building customer-facing AI features, the operational overhead probably exceeds the cloud cost — and you can't legally use the self-hosted version commercially as a multi-tenant product anyway.

Worth paying for?

Sandbox is a demo. Don't plan to do real work on it.

Pro at $59/month is the right starting point for any solo dev or 2-3 person team who wants to ship an LLM feature without operating their own agent infrastructure. The credits will run out fast if you're doing anything ambitious, but the price-to-time-saved ratio is excellent. Easy yes.

Team at $159/month is the standard play for any growing AI-native startup. The Langfuse integration alone is worth $40 of the markup if you're serious about observability. The 50-seat cap removes the noise, the unlimited triggers remove the second-biggest gotcha. If you're past the prototype stage, this is where you live.

Enterprise is real money for real companies. If you're building a product on top of Dify, you don't have a choice — the multi-tenant license clause makes the cloud or self-hosted Enterprise license mandatory.

Self-host if you have ops capacity and you're deploying internal-only AI tools. The community edition is feature-complete for that case. The licensing trap only triggers when you start serving external customers.

The honest take: Dify's pricing is reasonable for what it is, but the message-credit metering will bite anyone who underestimates how many model calls a real agent makes. Budget for 3-5x the credits you'd naively expect, and pick your tier based on the team-size and trigger limits, not the headline credit allocation. And if you ever plan to wrap Dify in a product you sell to others, read the license modification carefully before you build anything — the word "Apache" is doing a lot of work in that filename, and the modification underneath is the actual rule.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Dify open source?

Yes, but under a modified Apache 2.0 license. The modification adds two clauses: no multi-tenant use without written permission, and no removing the Dify logo from the console or apps.

What's the cheapest paid Dify plan?

Pro at $59/month ($590/year with 17% off) — 5,000 message credits/month, 1 workspace, 3 team members, 50 apps, 500 knowledge documents, and 5GB knowledge storage.

Can I use the self-hosted Community Edition to build a SaaS on top of Dify?

No. The modified Apache 2.0 license bans operating Dify in a multi-tenant environment without written permission from LangGenius. Internal self-hosting at one company is fine; reselling to external customers requires a commercial Enterprise license.

What is a Dify message credit?

Roughly one LLM completion — a chatbot reply, an agent step, or a workflow execution that calls a model. A single multi-step agent conversation can burn 5–15 credits, so 5,000 Pro credits go faster than they look.

When should I upgrade from Pro to Team?

When you hit the 3-seat cap, the 20k trigger cap, or need the Langsmith/Langfuse integration. Team at $159/month is a 2.7x price jump for 2x credits, but the seat and trigger limits are usually what force the upgrade, not the credits.

Documenso Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:34:03 +0000

TL;DR

Documenso is the open-source DocuSign alternative — 12.7k stars, AGPL-3.0 licensed, hosted from $0 to $250/month. The actual product you're paying for at the $250 Platform tier is permission to embed under a non-AGPL license, not features.

Free forever for low-volume users (5 docs/month, no watermark, no card required)
Teams at $40/month is the SMB sweet spot — a 20-person company at $160/mo lands well under DocuSign's equivalent
Platform at $250/month flat is the AGPL escape hatch for embedded or white-labeled use
Vs. DocuSign per-envelope billing, Documenso wins big at scale (e.g., $250 vs. $25,000+/mo at 50k signs)
Self-host for internal use only — AGPL still applies if you embed Documenso into a SaaS you sell

Hey, it's Vlad, founder of Beton.

Documenso bills itself as "the open source DocuSign alternative." 12.7k stars on GitHub, AGPL-3.0 licensed, hosted product from $0 to $250/month across four tiers. The most interesting thing about it isn't the prices — it's what AGPL-3.0 does to the buying decision.

This post is a part of series on commercial open source software pricing.

What is Documenso

Open source e-signature. You upload a PDF, drag signature fields onto it, send it, recipients sign, you get a sealed PDF with an audit trail. Same loop as DocuSign, Dropbox Sign, Adobe Sign, PandaDoc — but the source is on GitHub.

Website: documenso.com
Pricing: documenso.com/pricing
GitHub: github.com/documenso/documenso — 12.7k stars
License: AGPL-3.0 (this matters — see below)

For context: DocuSign does ~$3B/year at a $15B+ market cap. Dropbox Sign and Adobe Sign carve up most of the rest. Documenso is the open source insurgent — not at scale yet, but the only credible "we run the source ourselves" option in the category. Even Google Docs has launched their own e-sign in a "make your complements free" defensive move.

The AGPL-3.0 gate

The license does most of the work the sales team would otherwise have to do.

AGPL-3.0 is the most aggressive permissive-adjacent OSS license in widespread use. It's GPL with one extra clause: if you run AGPL software over a network and let users interact with it, you must release your modified source to those users. Fork Documenso, host it, let your customers sign through your product, and you have to release whatever you built around it under AGPL too.

Self-hosting an internal company instance? Fine — your "users" are employees, and the source is already public. Embedding Documenso into a SaaS you sell to others? Not fine — your product becomes a "derivative work" the moment it links to Documenso's, and most commercial codebases cannot ship AGPL-derived code without becoming legally encumbered.

This is why the Platform plan exists at $250/month. It's not a feature tier — it's the AGPL escape hatch. White-labeling, embedded signing, unlimited API are real features, but the actual thing you're paying $250/month for is permission.

DocuSign and Dropbox Sign extract revenue through per-envelope pricing. Documenso extracts it through licensing. Same destination, different road.

Pricing structure

Hosted plans:

Free — $0/month. 5 documents/month, up to 10 recipients per doc, no credit card. Free forever, not a trial.
Individual — $30/month ($300/year, effectively $25/mo annual). Unlimited documents, API access for personal use, email support.
Teams — $48/month ($480/year, effectively $40/mo annual). 5 included users + $8/mo per additional user. Unlimited documents, embedded signing, API access for automation.
Platform — $300/month ($3,000/year, effectively $250/mo annual). Unlimited users, documents, API. Embedded signing with white-label, Slack support. This is the AGPL commercial license tier.
Enterprise — talk to sales. Cloud or self-hosted, advanced compliance, tailored support.

Self-hosted:

Community Edition (free, AGPL-3.0). Unlimited signatures, no envelope cap, full feature parity for internal use. The catch is you take on AGPL's obligations.
Enterprise (self-hosted). Custom commercial license for orgs that want self-hosting and commercial-product embedding.

The Free tier is unusually generous

Most signing tools give you a "free trial" — 3 signs, then the wall. Documenso's Free is 5 documents per month, indefinitely, no credit card, no watermark, 10 recipients per doc. DocuSign's free is a 30-day trial. Dropbox Sign's free is 3 docs/month with watermarks. Adobe Sign has none.

That's enough to handle a freelancer's contract flow or an indie founder's NDAs without ever paying. Hit the cap, and the upgrade to Individual at $25 is right there. Product-led growth with the brakes off.

The pricing cliff

Individual ($25) → Teams ($40) → Platform ($250). The first jump is fine. The second is dramatic: $210/month more for "unlimited everything."

In practice, you don't pay Platform because you ran out of seats — Teams scales linearly at $8/extra user and most growing companies could ride it indefinitely. You pay $250 because you crossed a specific Rubicon: you want to embed Documenso into a product you sell.

The marketing copy calls Platform "perfect for builders." That understates it. White-label and unlimited API are window dressing on a license sale. For internal-use companies — even very large ones — Teams is the right answer through hundreds of employees.

Vs. DocuSign: the math depends on volume

DocuSign API plans start around $20/month for 10 envelopes, then scale to $0.50–$2.00 per envelope at enterprise volume. Dropbox Sign runs similar: $99/month base for 200 requests + overage. Documenso Platform is $250/month flat, unlimited.

500 signs/month on DocuSign at ~$1/envelope = $500/mo. Documenso = $250/mo flat.
5,000 signs/month at $0.50/envelope = $2,500/mo. Documenso = $250/mo flat.
50,000 signs/month = $25k+/mo on DocuSign. Documenso = still $250.

For any product team building signing into their own SaaS, the comparison isn't "Documenso vs. DocuSign as e-sig tools." It's "$250/month flat vs. a tax that scales with your customer adoption."

The trade-off: DocuSign's brand, audit certifications stack, and integration surface (Salesforce, Workday, every legal tool ships a connector) are real assets — especially for a SaaS selling into Fortune 500 procurement. For technical buyers with high signature volume, Documenso Platform is the rational choice anyway.

Self-hosting the AGPL way

The repo ships Docker compose and a Helm chart. The stack is PostgreSQL, Redis, the server, and SMTP — smaller than most COSS deployments. Operationally you take on TLS, backups, SMTP, security review, and AGPL obligations if you ever expose it externally.

For internal-use deployments at a single company, self-hosting is right once you're past Teams' break-even or have hard data-residency requirements. For embedding into a commercial product, self-hosting is not a way around Platform — AGPL still applies, and most proprietary codebases can't accept that.

Worth paying for?

Free is genuinely usable for low-volume individuals. 5 docs/month with no watermark is more than most people's actual contract flow.

Individual at $25/month is a clean upgrade if you hit Free's cap and sign more than 5 things a month.

Teams at $40/month is the SMB sweet spot. A 20-person company at $160/mo lands well under DocuSign's equivalent.

Platform at $250/month is the right answer if and only if you're embedding Documenso into a product. The features are valuable; the AGPL escape hatch is the actual line item. If you're not embedding, you're overpaying.

Self-host if you have ops capacity and you only need internal use. Don't self-host as a way to dodge Platform if you intend to embed — AGPL doesn't permit that.

The honest take: Documenso's pricing is built around one strategic bet — that DocuSign's per-envelope billing is the category's biggest weakness for technical buyers, and that AGPL is a clean enough fence to monetize the people who want to escape it. For internal-use customers, Teams is the obvious win. For builders, Platform's $250/month against unlimited envelopes is one of the better deals in dev tools — as long as you understand the actual product you're buying is a license, not a feature set.

How Documenso pricing scales

Documenso's tiers climb gently until the $250 Platform plan — which you pay not for features but for permission to embed under a non-AGPL license.

Documenso pricing by tier. Platform is the AGPL escape hatch, not a feature jump.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Documenso open source?

Yes, AGPL-3.0. The full product — UI, API, document workflow, audit trail — ships under AGPL on GitHub. Self-hosting is supported via Docker compose and a Helm chart.

What's the cheapest paid Documenso plan?

$25/month effective on Individual ($300/year prepay), or $40/month effective on Teams ($480/year, 5 users included plus $8/user beyond).

Does AGPL allow embedding Documenso into a commercial product?

No. AGPL requires you to release any product that links to Documenso under AGPL too. Embedded or white-labeled use requires the $250/month Platform plan or a self-hosted Enterprise commercial license.

When does Documenso beat DocuSign on price?

Documenso Platform is $250/month flat for unlimited envelopes; DocuSign charges roughly $0.50–$2 per envelope. The break-even is around 250–500 signatures/month — beyond that Documenso wins, and the gap widens fast at scale.

Firecrawl Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:33:59 +0000

TL;DR

Firecrawl runs one of the smartest GTM setups in OSS web scraping. The core engine is AGPL-3.0 (so competitors can't fork-and-host as a service). Fire Enrich and other extensions are MIT-licensed (so the funnel runs free).

Self-hosting is technically possible but operationally painful — proxies, headless browser pools, anti-bot detection at scale.
Credit-based pricing: 1 page = 1 credit. Free 500 credits, Hobby $16/mo (3k credits), Standard ~$83–99/mo (100k), Growth $333/mo (500k).
AI Extract is a separate subscription starting at $89/mo — easy to miss when budgeting.
Lower tiers cap crawls at 50 pages, which gets painful fast on docs, catalogs, archives.
The bet: freshness beats cheapness. Worth paying if you're building AI agents that need real-time web data.

Hey, it's Vlad, founder of Beton.

I've had a habit of writing on pricing of COSS (commercial open source software) companies. Want to bring it back to life.

First one is Firecrawl.

Firecrawl has one of the smartest GTM setups I've seen in open source. The trick isn't in the pricing page — it's in the licensing.

How Firecrawl pricing scales

Firecrawl scales by credits in flat tiers, plus a separate AI-Extract subscription that's easy to miss when budgeting.

Firecrawl pricing by tier (credit-based). AI Extract is billed separately from $89/mo.

This post is a part of series on commercial open source software pricing.

What is Firecrawl

Firecrawl is a web scraping API that turns websites into LLM-ready markdown or structured data.

Think of it as the plumbing layer between "the internet" and your AI agent — it handles proxies, JavaScript rendering, anti-bot bypasses and gives you clean output.

They've raised from Y Combinator and are growing fast in the AI tooling space.

The licensing play

This is where it gets interesting. Firecrawl doesn't have one product — it has two, with very different licenses.

The core scraping engine is AGPL-3.0

You can self-host it, sure.

But AGPL means that if you wrap it into your product and serve it to users, you have to open source your entire codebase.

So competitors can't just take Firecrawl and build their own UI on top. And even if you self-host it just for internal use — good luck juggling rotating proxies, headless browsers and anti-bot detection at scale.

That's the hard part. That's what you're actually paying Firecrawl for when you buy their cloud.

Fire Enrich (and many other Firecrawl-based tools) are MIT

This is their data enrichment tool — 650+ stars, fully open, do whatever you want with it. You could fork it and build a competing product tomorrow.

But here's the thing: Fire Enrich is basically a collection of small system prompts that call GPT and tell it to go scrape the web for company data.

Each "agent" is a thin wrapper.

So when you use it, you end up paying Firecrawl for scraping infrastructure and OpenAI for tokens.

The MIT license is generous because the product is a funnel, not a moat. Smart. Really smart.

Pricing structure

Firecrawl uses credit-based pricing: 1 page scraped = 1 credit.

Scrape & Crawl plans:

Free — 500 credits, no credit card required. Enough to test
Hobby — $16/month for 3,000 credits (~$0.005/page)
Standard — ~$83-99/month for 100,000 credits + 50 concurrent browsers
Growth — $333/month for 500,000 credits + 100 concurrent browsers
Enterprise — custom pricing, sales call

But here's what catches people off guard: the AI extract feature is a completely separate subscription.

It runs on tokens, not credits. Starts at $89/month.

So if you thought your Standard plan covers everything — it doesn't. You need two subscriptions to use the full product.

Extract plans (separate):

Starter — $89/month
Explorer — $359/month
Pro — $719/month

Lower-tier plans also cap crawls at 50 pages, which gets painful fast if you're scraping anything with depth — docs, catalogs, archives.

Does it make sense to pay?

Almost certainly yes, if you're building AI agents that need web data.

Self-hosting Firecrawl is technically possible but practically painful. Web scraping at scale is an infrastructure nightmare — you need proxy rotation, browser pools, retry logic, anti-detection.

This is the kind of thing where "just run a Docker" doesn't cut it.

Unlike ClickHouse or Metabase where the self-hosted version is genuinely usable, Firecrawl's value is the managed infrastructure.

The real question is whether the cost per contact makes sense for enrichment use cases.

When you use Fire Enrich, you're not buying a database lookup at fractions of a cent. You're scraping live web pages and running LLM inference on every single query.

That adds up fast — scraping credits + OpenAI tokens per contact.

For high-volume enrichment (think Clay or Apollo scale), this could get expensive compared to traditional data providers that pre-crawl and cache everything.

Firecrawl's bet is that freshness beats cheapness. Instead of stale database records, you get real-time data every time.

Whether that tradeoff works depends on your volume and how much you care about data being current vs. data being cheap.

FAQ

Is Firecrawl open source?

Yes — the scraping core is AGPL-3.0. Fire Enrich and several Firecrawl-based extension tools are MIT-licensed.

Can I self-host Firecrawl for free?

Technically yes — the AGPL repo is public. In practice you take on proxy rotation, headless browser pools, retry logic, and anti-bot detection at scale. The managed cloud is what you're really paying for.

How much does Firecrawl cost for 100k pages/month?

Around $83–$99/month on the Standard plan, plus separate AI Extract pricing if you use that feature (starts at $89/mo).

Does AGPL prevent commercial use of Firecrawl?

No — internal company use is fine. AGPL only bites if you build a public product that wraps Firecrawl, in which case you need the cloud subscription or a commercial license.

Grafana Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:33:55 +0000

TL;DR

Grafana is the observability stack most engineers have already touched — metrics, logs, traces, profiles, k6 load tests, all in one place. ~66k GitHub stars, AGPL on the core, and a cloud business explicitly positioned against Datadog bill shock. The pricing story is five usage meters, a generous free tier on volume but tight on retention, and a steep cliff from Pro to Enterprise.

Free forever — all services, 14-day metric retention, 3-day log retention
Pro starts at $19/month minimum + pay-as-you-go on five meters (metrics, logs, traces, profiles, k6)
Enterprise starts at a $25,000/year spend commit with nothing in between Pro and Enterprise
Adaptive metrics auto-drops unqueried series — the explicit answer to Datadog overage horror stories
AGPL on core Grafana (Apache 2.0 on Agent/Alloy); enterprise plugins ship under separate commercial licenses

This post is a part of series on commercial open source software pricing. See full list of articles here.

Grafana is the observability platform most engineers have used without realizing it — metrics visualization, log aggregation, distributed tracing, all in one place. ~66k GitHub stars, which puts it in the "foundational infrastructure" category alongside tools like Kubernetes and Prometheus. Grafana Labs has built a full cloud observability stack (Loki for logs, Tempo for traces, Mimir for metrics) to compete directly with Datadog, New Relic, and Dynatrace.

Plans

Free: Always free, all services, limited usage per month. 14-day metric retention, 3-day log retention.
Pro — from $19/month + usage: Pay-as-you-go above free tier limits. 13 months metrics retention, 30 days logs. Starts at $19/month as the minimum.
Enterprise — starts at $25,000/year spend commit: Full enterprise features, SLA, dedicated support, advanced RBAC, data source permissions.

Usage dimensions: metrics, logs, traces, profiles, k6

Most observability tools pick one or two dimensions to charge on. Grafana has five active meters:

Metrics: Per active series
Logs: Per GB ingested
Traces: Per GB ingested
Profiles: Per GB ingested
k6 tests: Per virtual user hour

This is the "bring your own complexity" model. If you're running a simple stack with a handful of services, your bill is low. If you're running a large distributed system that emits high-cardinality metrics + verbose logs + distributed traces, every meter is running.

The upside vs Datadog: each meter is individually transparent and relatively cheap. You can tune each one by reducing cardinality, adjusting sampling rates, or filtering noisy logs. Datadog's pricing is notoriously opaque; Grafana publishes per-unit rates and you can model your costs.

The "Datadog bill shock" positioning

Grafana explicitly markets against Datadog's infamous overage bills. Their adaptive metrics feature automatically drops series that aren't being queried — reducing your active series count and bill without requiring manual intervention.

This is smart positioning. Datadog horror stories (teams getting $300k/month surprise bills) spread virally in the engineering community. Grafana is the "we know Datadog's rep, here's how we're different" pitch.

Whether it holds up at scale depends on your specific usage patterns. Teams that emit lots of metrics with high cardinality (user IDs, request IDs as label dimensions) will still have expensive bills on any platform. Grafana's tooling helps, but it doesn't save you from yourself if your instrumentation is undisciplined.

The free tier is genuinely generous

14-day metric retention and 3-day log retention on a free tier is more than most comparable tools offer. For a developer testing instrumentation or a small project, this is usable — not just a demo.

The catch is retention, not usage volume. 3-day log retention makes production debugging painful. "We had an incident 5 days ago and need the logs" is a very normal request. Free tier doesn't support it.

The $25,000 enterprise cliff

There's no "upper mid-market" tier between Pro (pay-as-you-go) and Enterprise ($25k/year). If you need enterprise SSO, advanced RBAC, data source permissions, or an SLA, the minimum spend is $25,000/year.

That's a hard wall. A 50-person company that's grown out of Pro's self-service but doesn't need everything in Enterprise is stuck choosing between overpaying for Enterprise or finding workarounds. The gap between Pro and Enterprise pricing is one of the steepest in this series.

License

AGPL for core Grafana. Apache 2.0 for several components (Grafana Agent, Alloy). AGPL means modifications to Grafana itself must be open-sourced if distributed — but running a private Grafana instance internally is fine. Some enterprise plugins have commercial licenses separate from the core.

Worth paying for?

Free tier is a good starting point and genuinely usable for small/medium projects. Pro's pay-as-you-go is the right model for most growing companies — you pay for what you use, and the per-unit rates are transparent. Self-hosting is a real option for cost control and data sovereignty. Enterprise at $25k/year is justified for large engineering orgs with compliance requirements — but it's a significant commitment with nothing in between.

How Grafana pricing scales

Grafana's Pro tier starts at a $19/month minimum then meters five separate signals; the next step is a $25,000/year Enterprise commit (~$2,083/month) with nothing in between.

Grafana pricing by tier. The Pro→Enterprise cliff is the steepest in the series.

This post is a part of series on commercial open source software pricing. See full list of articles here.

I build Beton — open source revenue intelligence for B2B SaaS.

FAQ

Is Grafana open source?

Core Grafana is AGPL. Grafana Agent and Alloy are Apache 2.0. AGPL means modifications to Grafana itself must be open-sourced if distributed, but running a private Grafana instance internally is fine. Some enterprise plugins ship under separate commercial licenses.

What does Grafana Cloud actually charge for?

Five usage meters: metrics (per active series), logs (per GB ingested), traces (per GB ingested), profiles (per GB ingested), and k6 tests (per virtual user hour). Each meter is individually transparent with published per-unit rates.

How much is the cheapest paid plan?

Pro starts at $19/month as the minimum, then pay-as-you-go above the free tier limits. You get 13 months of metrics retention and 30 days of logs retention.

Why is the jump from Pro to Enterprise so steep?

There is no upper-mid-market tier. Enterprise SSO, advanced RBAC, data source permissions, and SLA all live behind a $25,000/year minimum spend commit. A mid-sized team that has outgrown Pro's self-service but doesn't need everything in Enterprise has no clean option.

How does Grafana position against Datadog?

Explicitly on bill predictability. Adaptive metrics automatically drops series that aren't being queried, reducing active series count without manual cleanup. Per-meter rates are published so you can model costs — the opposite of Datadog's opaque overage model.

Infisical Pricing Teardown 2026

Vlad Nadymov — Wed, 27 May 2026 09:33:52 +0000

TL;DR

Infisical is the open-source secrets manager going after HashiCorp Vault from below — 25,700+ GitHub stars, MIT-licensed core, with enterprise features under a proprietary license inside backend/src/ee/. Pricing is identity-based at $18/month per identity, where an "identity" counts both humans and machines.

Free tier covers 5 identities, 3 projects, all integrations, and self-hosting — genuinely usable for solo devs
Pro at $18/month per identity unlocks SAML SSO, RBAC, secret versioning, IP allowlisting, and 90-day audit logs
Enterprise (custom pricing) gates dynamic secrets, SCIM, LDAP, approval workflows, KMIP, and HSM support
Identity-based billing scales faster than seat-based — 10 devs + 20 machine identities = $540/month
Self-hosting is real on the MIT core, but enterprise features still need a license key that phones home

Hey, it's Vlad, founder of Beton.

Infisical is the open-source secrets manager that's been eating into HashiCorp Vault's territory from below. The pitch is simple: Vault is powerful but painful. Infisical is Vault for teams that don't want to hire a dedicated Vault engineer.

25,700+ GitHub stars, founded in 2022, growing fast in the DevOps/platform engineering space. Let's look at how they make money.

How Infisical pricing scales

Infisical bills per identity — and an identity is any human OR machine (a CI pipeline, a service account, an agent). Machine identities usually outnumber people, so the bill scales faster than headcount suggests.

Monthly cost as Infisical scales by identity (humans + machines all count).

This post is a part of series on commercial open source software pricing.

What is Infisical

Infisical is an open-source platform for secrets management, certificate management (PKI), SSH key management, and privileged access management (PAM).

Think of it as the layer that stores your API keys, database passwords, certificates, and environment variables — then distributes them to your apps, CI/CD pipelines, and infrastructure through integrations with AWS, Kubernetes, Terraform, GitHub Actions, GitLab CI/CD, Docker, Jenkins, Ansible, and dozens more.

They also handle secret rotation, dynamic secrets (short-lived credentials generated on demand), secret scanning and leak prevention, and audit logging. It's a full platform, not just a key-value store.

They've raised venture capital and are positioning themselves as the modern alternative to HashiCorp Vault for teams that want something operational without a PhD in HCL configuration.

The licensing play

This one is a textbook open-core split, executed cleanly.

The core platform is MIT

The main codebase — the API server, CLI, SDKs, Kubernetes operator, agent, dashboard UI, all integrations — is MIT licensed. Do whatever you want with it. Fork it, embed it, sell it. No strings.

This is generous. More generous than AGPL (which Plane and many others use), and more generous than the various "sustainable use" or "source available" licenses. MIT is real open source, no asterisks.

Enterprise features live under a proprietary license

Everything inside the backend/src/ee/ directory (over 800 files) is covered by the Infisical Enterprise License. You can read the code on GitHub, but you can't run it in production without purchasing a license key.

The enterprise license is straightforward: you can modify the code and publish patches, but Infisical retains all rights to those modifications, and you can only use them with a valid subscription for the correct number of user seats. You can copy and modify for development and testing without a subscription.

The enterprise-gated features include:

SAML SSO (Okta, Azure AD, JumpCloud) and OIDC — this is on Pro, not Enterprise
SCIM provisioning
LDAP authentication
Dynamic secrets
Secret approval workflows and access requests
Audit log streaming and custom retention
User groups and custom roles
Sub-organizations
KMIP and HSM support
Gateways for private network access
IP allowlisting
Secret rotation

Here's the interesting part: SAML SSO and RBAC are gated at the Pro tier, not Enterprise. This means even mid-size teams hit a paywall the moment they need anything beyond Google/GitHub SSO or basic role assignment. That's a smart trigger — SSO is usually the first enterprise requirement any growing team runs into.

Google SSO and GitHub SSO are free across both cloud and self-hosted. So the free tier isn't crippled for small teams that standardize on one of those providers.

Pricing structure

Infisical uses identity-based pricing. An "identity" is either a human user or a machine identity (a service, CI/CD pipeline, Kubernetes service account, or agent that authenticates to Infisical). This is the key detail.

Free — $0/month

Up to 5 identities
Up to 3 projects
Up to 3 environments per project
Up to 10 integrations
Dashboard UI, API, CLI, SDKs
Kubernetes Operator, Infisical Agent
All third-party integrations (AWS, Vercel, GitHub Actions, GitLab CI/CD, Jenkins, Ansible, etc.)
Webhooks, 2FA
Secret referencing and overrides
Secret scanning and leak prevention
Secret sharing
Self-hosting or Infisical Cloud
Community Slack support

Pro — $18/month per identity

Everything in Free, plus:
Unlimited projects, environments, and integrations
Secret versioning
Point-in-time recovery
Role-based access controls
Secret rotation
Temporary access provisioning
SAML SSO
IP allowlisting
90-day audit log retention
Higher rate limits
Priority support
Free trial available

Enterprise — custom pricing (contact sales)

Everything in Pro, plus:
Dedicated infrastructure
Enterprise SCIM
LDAP authentication
Dynamic secrets
AI Security Advisor
Approval workflows
Access requests
Gateways
Sub-organizations
KMIP
KMS & HSM support
Audit log streaming
Custom audit log retention
Custom rate limits
User groups and custom roles
99.99% SLA
SOC2 & PenTest reports
Dedicated support engineer

The Pro tier slider goes from 1 to 50 identities on the pricing page. Beyond that, you're in Enterprise territory.

The identity pricing model

This is where Infisical gets clever — and potentially expensive.

Most secrets managers charge per user (human). Infisical charges per identity, which includes both humans and machines.

If you have 10 developers and 20 machine identities (production apps, CI/CD pipelines, staging environments, Kubernetes service accounts), you're paying for 30 identities at $18/month each. That's $540/month, or $6,480/year.

The free tier gives you 5 identities total. For a solo developer with a couple of apps and a CI pipeline, that's workable. For a team of 5 engineers? You've already used all your identities on humans alone, with zero machine identities.

The upgrade trigger is effectively: "the moment you have more than 5 things talking to Infisical." That's early. Very early.

Their FAQ even includes: "If I upgrade to Pro, do I keep the 5 free identities from the Free plan?" — which tells you this is a common friction point users hit.

Does it make sense to pay?

For small teams (under 5 people, a few services): the free tier is legitimately usable. MIT-licensed self-hosting means you can run it on your own infrastructure with no licensing cost and no catch. All integrations are included. If you only need Google or GitHub SSO, you're covered. This is a real free tier, not a demo.

For growing teams (10-30 engineers): yes, paying makes sense. The alternative is HashiCorp Vault, which requires significant operational expertise. A team of 15 engineers with 25 machine identities would pay $720/month for Pro. That's less than the salary cost of the fractional DevOps time you'd spend wrestling with Vault policies, token renewal, and seal/unseal ceremonies.

The real question is whether you need Pro or Enterprise. The Enterprise tier gates some features that many teams consider essential once they hit a certain maturity: dynamic secrets, approval workflows, SCIM provisioning, LDAP. If your organization uses Okta or Azure AD for everything, you'll need at least Pro for SAML SSO.

For self-hosting: this is where it gets nuanced. The MIT-licensed core is genuinely complete for basic secrets management. You can self-host it, use all integrations, and pay nothing. But the moment you need RBAC, secret versioning, or SSO beyond Google/GitHub, you need a Pro license. And for dynamic secrets, SCIM, or LDAP, you need an Enterprise license — even on your own infrastructure.

Self-hosting Infisical isn't like self-hosting Vault where you get everything for free. The enterprise features require a license key that phones home to Infisical's license server (or an offline key for air-gapped environments). This is the standard open-core playbook: the deployment is yours, but the premium features are still paywalled.

Bottom line: the identity-based pricing model is elegant but it scales faster than pure seat-based pricing. Every new microservice, every new CI/CD pipeline, every new Kubernetes namespace that needs its own credentials — they all count. For organizations with many services and few humans, this can add up quickly. For small teams with a handful of services, it's straightforward and reasonably priced.

The MIT license on the core is the most permissive in this series so far. If you just need a secrets store with good integrations and don't need the enterprise security features, you genuinely get a complete product for free. That's the real wedge against Vault.

FAQ

Is Infisical open source?

Yes — the core platform (API server, CLI, SDKs, Kubernetes operator, agent, dashboard UI, all integrations) is MIT-licensed. Everything under backend/src/ee/ (800+ files) is covered by the proprietary Infisical Enterprise License and requires a paid subscription to run in production.

What counts as an 'identity' in Infisical pricing?

Both humans and machines. A user, a service, a CI/CD pipeline, a Kubernetes service account, or an agent that authenticates to Infisical each counts as one identity at $18/month on the Pro tier.

What's the cheapest paid Infisical plan?

Pro at $18/month per identity. The pricing-page slider runs from 1 to 50 identities; beyond that you're in Enterprise territory with custom pricing.

Can I self-host Infisical for free?

Yes for the MIT core — full secrets management, all third-party integrations, Google and GitHub SSO, no licensing cost. But RBAC, SAML SSO, secret versioning, dynamic secrets, SCIM, and LDAP all require a Pro or Enterprise license key, even on your own infrastructure.

When does Infisical make sense vs. HashiCorp Vault?

For growing teams (10–30 engineers) that don't want to hire a Vault specialist. A 15-engineer team with 25 machine identities pays $720/month for Pro — less than the fractional DevOps cost of operating Vault policies, token renewal, and seal/unseal ceremonies.