The cost of self-hosting

Tree's hosting model is slightly unusual. The core product will be free. Team plans will be paid but cheap. Self-hosting will be available as a one-time license, not a subscription. This combination is rare in modern SaaS, and the reasons we chose it are worth explaining.

This post is the decision tree behind Tree's pricing model. Why not subscription. Why not pure open-source. Why not freemium-with-aggressive-upsell. Each path has costs, and we've picked the combination of costs we're most willing to live with.

The four hosting models

Most modern software products pick one of four pricing models for hosted vs self-hosted access.

Pure SaaS subscription. The product runs on the vendor's servers, customers pay monthly per user, no self-hosting option exists. This is Linear, Notion, Asana, Monday, most of the modern indie tool set. The model is clean, scalable, and predictable.

SaaS with self-hosted enterprise tier. The product is primarily SaaS, but a self-hosted version exists for enterprise customers willing to pay significantly more. Self-hosting is positioned as premium. Examples: GitLab, Sentry, Plausible. The model captures both the SaaS market and the data-sovereignty market without conflict.

Open-source with hosted offering. The product is open-source and free to self-host. The vendor offers a hosted version for users who don't want to operate the infrastructure themselves. Plane, Outline, Cal.com, many indie tools. The model is community-friendly and produces strong distribution but generates less revenue per user.

Open-core. The base product is open-source. Premium features (SSO, advanced reporting, audit logs) are proprietary and sold through licenses. The hosted version includes both. GitLab, Mattermost, Strapi. The model captures enterprise customers without giving away the keys to the kingdom.

Tree's model is closest to a fifth option that doesn't have a standard name: free SaaS for personal use, paid SaaS for teams, paid one-time license for self-hosting. The model is unusual because the self-hosting price is a lifetime purchase, not a recurring fee, and because the SaaS and self-hosted versions are functionally identical.

Why not subscription only

The dominant model in our category is pure SaaS subscription. Linear charges per user per month. Notion does the same. So does almost everyone else.

We considered this model and rejected it for two reasons.

The first reason is philosophical. Subscriptions for software you host yourself are a small crime. If a user is running the software on their own infrastructure, paying their own bandwidth, managing their own backups, and absorbing their own operational costs, charging them a recurring fee for the right to keep using it is unjustifiable. The vendor isn't providing ongoing service. The user is providing the service to themselves. The recurring fee is rent extraction with no underlying value.

The second reason is alignment. A subscription model creates pressure to ship features that justify the recurring spend. Customers ask "what are we paying for this month," and the vendor has to keep producing visible answers. This pressure is what produces feature bloat, AI assistants, and quarterly UI redesigns whose primary purpose is being demonstrable in renewal conversations. The model itself shapes the product.

A one-time license aligns differently. The user pays once. The vendor's incentive is to make the license valuable enough to recommend, not to generate ongoing renewal pressure. The product can stay focused.

For SaaS users, we still charge per month, because we're actually providing ongoing service (hosting, uptime, support). The recurring fee is honest in that context. For self-hosted users, the recurring fee would be dishonest, so we don't charge it.

Why not pure open-source

We considered going fully open-source. Most indie tools in our space are: Plane, Outline, Cal.com, Excalidraw. The pattern works for them.

We rejected pure open-source for one main reason: we want to be sustainable as a company without depending on a hosted offering as the entire revenue model.

Open-source projects with a hosted offering have a structural challenge. The hosted version has to be meaningfully better than the self-hosted version, or users pick the free option. This usually means the hosted version gets enterprise features (SSO, advanced reporting, team management) that the self-hosted version doesn't. The split between editions becomes a constant negotiation: which features go where, who gets what, when does a free user become a paid one.

The negotiation tends toward open-core, where the proprietary "premium" features grow over time and the open-source base becomes a marketing channel for the paid version. This produces a tool whose open-source claim is technically true but practically narrow.

We didn't want this. The model we chose is proprietary. Tree's source code is not public, we don't ship under an OSI license, and there's no community contribution model. The self-hosted license is paid, but it's a one-time purchase, and it includes everything the SaaS version has at the same tier. There's no premium tier withheld for hosted users only.

This is unconventional. It's also honest. Self-hosters who need paid features pay for the license once, run the software forever, and aren't dependent on us for anything except optional updates. We don't have a hosted-only tier to upsell into. The model is symmetric.

Why not freemium with aggressive limits

A common indie SaaS model is freemium with aggressive feature limits. Free users get the basic product with strict caps (e.g., 100 tasks, 1 project, 2 team members). Paid users get the real product. The free tier is a lead magnet for the paid one.

We rejected this for a reason that mirrors the subscription decision: alignment.

Aggressive freemium creates pressure to make the free tier just barely useful. The product gets engineered to push users toward paying, with friction added where the team thinks users will tolerate it. The result is a product that feels degraded for free users, which is the entire point of the model from a revenue perspective.

We don't want a degraded free tier. The free tier is for personal projects and small teams who don't have budget. We want it to be genuinely useful, not a teaser. This is the opposite of what aggressive freemium incentivizes.

Our free tier has caps, but they're set generously. A solo user planning their personal projects should never hit them. A small team trying out Tree should be able to use it for real work without conversion friction. The team plans exist for teams that have grown past those caps, not as gates between basic and real product use.

This means the conversion rate from free to paid will be lower than aggressive freemium would produce. We accept this. The trade is that free users get a real product, and paid users are paying because they actually need team features, not because they hit an artificial wall.

What this costs us

The pricing model has real costs. We should be honest about them.

Revenue per user is lower than pure SaaS would be. A self-hosted license is a one-time payment. A SaaS subscription compounds over time. For users who would have stayed for years, we leave money on the table.

Conversion is lower than aggressive freemium would be. Generous free tiers convert worse than gated ones. We've chosen a model where free users get more, which means fewer of them upgrade.

Customer acquisition is harder than open-source would be. Open-source projects benefit from organic distribution: contributors, GitHub stars, Reddit threads. Proprietary products get less of this because there's no public repo to fuel the loop. We're trading some of that distribution for revenue model flexibility.

These costs are real. The tradeoffs are deliberate. We'd rather have a sustainable business with aligned incentives than an unsustainable one with maximum reach.

Who this model fits

The model fits three audiences.

Personal users. Free, full-featured, no team caps that matter for individual use. The free tier is a real product, not a teaser.

Small teams. Cheap monthly subscriptions for hosted access. Lower than Linear, lower than Asana, set at a level that doesn't punish small teams for growing.

Self-hosters. One-time license for organizations that want full control of their infrastructure. Pay once, run forever, no recurring vendor lock-in. Includes all features. No premium tier withheld.

The model doesn't fit users who need enterprise compliance features (SSO, SAML, audit logs) at scale. We may add these eventually as a separate enterprise tier. Until then, organizations with those requirements should use Jira.

The summary

Tree's pricing is a deliberate combination: free for personal, cheap for teams, one-time license for self-hosting. The combination is unusual because most modern SaaS products pick one model and stick with it. We picked one for each customer segment, based on which incentives we wanted to live with for that segment.

Subscription rent on self-hosted software is unjustifiable. Open-core produces watered-down free editions. Aggressive freemium degrades the free tier on purpose. We rejected each of these in favor of a model where the incentives align with making a good product instead of with extracting maximum revenue per user.

The model has costs. The costs are deliberate. If you want a project tool whose pricing is shaped by aligned incentives rather than by industry default, join the waitlist.