
Multi-Tenant Architecture: 3 Models & 8 Best Practices
Learn how multi-tenant architecture works, compare database isolation models, and explore six components & eight best practices for shared infrastructure.
Product monetization explained: 7 models with real company examples, a 3-step way to choose one, common mistakes, and the infrastructure each model needs.
Most product monetization decisions get made in a planning doc, with a spreadsheet of tiers and a lot of confident arrows pointing at "Pro."
The real test comes months later in production, when the AI feature you bundled into Pro costs more to serve than the plan brings in, or a customer's agent burns through a month of credits overnight because the balance was checked after the requests ran.
Stigg runs entitlement and credit checks in the request path for AI products, including the AI credits launch at Miro, so we spend a lot of time watching pricing models meet real traffic.
You'll get the seven product monetization models with a real company behind each one, a three-step way to choose between them, the mistakes that cost teams the most, and the infrastructure every model runs on once it ships.
Product monetization is the strategy a company uses to turn the value its product delivers into revenue, made up of a pricing model (how customers pay), packaging (what each plan includes), and the systems that enforce both inside the product.
People often use "pricing" and "monetization" interchangeably, but pricing is one input. Monetization covers the whole structure: who pays, for which unit, in which plan, and what happens when a customer hits a limit.
Billing sits at the end of that chain, turning usage and subscriptions into invoices and collecting the money after the fact, which is why a billing system alone can't tell your product whether the next request should be allowed.
For AI products, the gap between those layers gets wider, since every request carries a real compute cost. The AI monetization guide goes deeper on that side, including how token costs change the math.
The seven most common product monetization models are tiered subscription, seat-based, freemium, usage-based, hybrid, credit-based, and add-ons, and most products end up combining two or three of them.
If you want the mechanics of each model in a software context, our SaaS monetization guide covers the architecture in more detail.
Customers pay a recurring fee for a plan, and each tier unlocks more features or higher limits than the one below it. Notion is a familiar version, with Free, Plus, Business, and Enterprise plans that add AI capabilities, connections, and admin controls as you move up.
Tiers are simple for buyers to compare, which is why so many products start here. What they ask of your product is a catalog that maps every plan to its features, an entitlement check whenever someone touches a gated feature, and a plan for grandfathering older tiers when the lineup changes.
The tiered pricing guide covers how teams structure the tiers themselves.
Customers pay per user, often with plan tiers layered on top. Slack charges per active member and counts anyone who takes an action within a 28-day period as active, so a team that stops using a seat gets a prorated credit back.
Seat pricing is predictable for both sides. The hard part is provisioning, since an admin who adds a user expects access instantly and an admin who removes one expects it gone, and enterprise contracts usually want seat counts synced with the CRM too.
A free tier gives people enough of the product to get hooked, and paid plans lift the limits. Dropbox Basic is the classic case, with 2 GB of storage and up to three connected devices for free, with paid plans for anyone who outgrows that.
Freemium lives or dies on the gate between free and paid, which is an entitlement check that returns "blocked, here's the upgrade" the moment a user hits the cap.
Feature gating works best when that check lives in one place. Copies of it in the API, the frontend, and background jobs drift apart, and the UI ends up blocking a feature the API still allows.
Customers pay for what they consume, such as API calls, tokens, gigabytes, or compute minutes. The OpenAI API is the obvious AI example, pricing each model per million input and output tokens.
Usage-based pricing lines revenue up with the value a customer gets (and with your cost to serve), though revenue gets harder to forecast. The product has to capture every usage event, attribute it to the right customer, and count retries once, which is the job of usage metering.
A base subscription includes an allowance, and usage past it is charged separately. Cursor works this way, where every plan includes a pool of AI usage, and third-party models are billed separately by usage on top of it.
Hybrid gives buyers a predictable floor and gives you upside on heavy users, which is why so many AI products land here.
It's also where homegrown systems tend to struggle, because subscription state and real-time consumption have to live together. The hybrid pricing model guide covers the mid-cycle upgrades and prorated allowances that make it tricky.
Customers get or buy credits and spend them on actions that cost different amounts, so one cheap query might burn 2 credits while a long agent run burns 50. Credits let you price several models and features in one unit, and the AI credits guide walks through how teams set the rates.
Miro, the visual collaboration platform, is a good example.
Its AI credits launch for Innovation Workspace needed credit allocation calculated from seat count, separate credit pools for trials, production, and beta features, and hard enforcement for some contract types with soft enforcement for others.
Miro had already put three engineers on its in-house entitlements service for three months. After moving to Stigg, it shipped the full hybrid seat-and-usage AI model in six weeks.
Under the hood, credits need an append-only ledger where each grant carries its own expiry, cost basis, category (paid or promotional), and burn priority, plus a rule for what happens at zero. A hard limit denies the request, and a soft limit lets the balance run into overdraft.
Customers buy specific capabilities on top of their plan, like extra usage, premium models, or compliance features.
Webflow, the website builder, sells Localization and Bandwidth add-ons, and after it moved entitlements to Stigg, rolling out a new add-on went from months to about four hours of configuration, minor code, and testing.
Add-ons multiply fast, since five of them already make 32 possible combinations. Each combination has to resolve to one clear set of entitlements, so the catalog should treat a customer's access as base plan plus active add-ons and work it out at runtime.
Two more models show up in most monetization guides, and they're worth knowing even though they rarely fit an AI or B2B software product.
The product is free (or cheap) for users, and advertisers or partners pay for access to that audience. Spotify runs both sides at once: the free tier plays ads, and Premium sells ad-free listening, so the ads fund free users and nudge them toward paying.
Partnerships work on the same logic with sponsored placements, integrations, or revenue shares. Both need a very large audience before the money adds up, which is why business software rarely relies on them.
You charge other companies to use technology you've built. Arm is the textbook case, licensing its processor designs to companies that build their own chips, and its Flexible Access program even pushes license fees back until a customer is ready to manufacture.
In software, the same idea covers selling an internal tool, SDK, or model to outside teams. It can be a great second revenue line, as long as you're ready to support a product for people who aren't you.
To choose a product monetization model, figure out who pays versus who uses, pick a value metric that tracks what customers get, and test pricing on a small group before rolling it out. The model usually follows from those three answers.
In B2C, the user and the buyer are usually the same person. In B2B, they often aren't, because a developer uses the product, a team lead approves it, and finance signs the contract.
The model has to work for the person paying. A per-seat price makes sense to a manager budgeting headcount, while a finance team watching AI spend may care more about a hard monthly cap than about the unit price.
A value metric is the unit you charge for, such as seats, documents processed, tokens, or credits. A good one grows when the customer gets more value, so the bill feels fair as usage scales.
For AI products, the metric also has to track your cost to serve. A flat per-seat price on a feature that runs expensive models can look great in the spreadsheet and lose money on your heaviest users, which is a big reason so many AI products move to credits or hybrid plans.
Run the new model with a slice of customers before you change the pricing page, such as new signups, one region, or a few design partners. You'll learn more from what people do at a real checkout than from any survey.
Testing like this puts a requirement on your system. Pricing has to live in configuration, with versioned plans, so a test cohort can see one price while existing customers stay on theirs. If every plan change needs a deploy, you'll run fewer experiments than you planned.
The most common product monetization mistakes are choosing a model too late, ignoring how customers pay, pricing below the cost to serve, hard-coding plans, enforcing limits after the fact, and overcomplicating tiers.
Every product monetization model runs on the same five layers: a product catalog, entitlements, metering, provisioning, and enforcement. Which one carries the most weight depends on the model.
A customer's effective entitlements combine several sources: their active plan, any base plan it inherits from, add-ons, trials, and promotional grants, with the most generous value winning when they conflict.
Entitlements are the layer most teams underestimate, because they look like a single if statement until the fifth source shows up.
Billing stays where it is. Stripe, Zuora, and similar providers handle invoices, tax, and payment collection, and the layers above decide what a customer is allowed to do before anything gets billed.
Enforcement has to run in the request path, before compute is spent. That's the difference between the overnight agent from the intro being stopped at its limit and showing up as a line item nobody can explain.
Speed decides whether teams keep the check switched on. Stigg's Sidecar runs next to your application and answers from an in-memory cache by default (with a Redis-backed persistent cache as an option), and on a cache miss it fetches from Stigg's Edge API at around 100 ms.
If that call times out (10 seconds by default, and configurable), the Sidecar returns the static defaults you configured, so a slow upstream call still ends with an answer your product can act on.
Enterprise buyers add one more requirement, which is budgets at every level of their org.
Limits that cover the organization, department, team, user, and individual agent let a runaway agent hit its own cap long before it drains the company's budget, and entitlement management at that depth is hard to bolt on later.
Building this layer in-house is the right call when the model is simple. One pricing model, a few plans, and predictable usage can run on a plans table, a handful of entitlement checks, and a Stripe integration, and plenty of teams ship exactly that.
The build gets harder when a second model arrives, when credits need several grant types with different expiry rules, when an enterprise prospect asks for per-team budgets, or when finance wants an event-level audit trail.
Each one is manageable alone, and together they turn a pricing feature into a system somebody has to own full time.
Miro is a useful reference point. It spent three engineers and three months on in-house entitlements before switching, shipped AI credits six weeks after adopting Stigg, and estimates it has saved 5,000 engineering hours, with pricing and packaging changes now moving six times faster.
There's a longer version of this argument in the engineer's case for buying, including where homegrown systems usually start to strain.
The product monetization model you pick today probably won't be the one you're running after your next big AI launch. That's fine, as long as the layer underneath can change with it.
Stigg is the usage runtime for AI products. It handles entitlements, credits, metering, and enforcement in the request path, and works alongside the billing you already run in Stripe, Zuora, or another provider.
With Stigg, teams can:
If you're weighing a model change and want to see how it would run on your stack, talk to a human at Stigg, or start with the AI quickstart in the docs.
Product monetization is the strategy a company uses to turn the value its product delivers into revenue. It covers the pricing model, the packaging of each plan, and the systems that enforce access and limits inside the product.
Common product monetization examples include Notion's tiered plans, Slack's per-active-user pricing, Dropbox's free Basic tier, the OpenAI API's per-token pricing, and Miro's AI credits. Spotify's ad-supported free tier and Arm's chip-design licensing are examples outside software subscriptions.
Product monetization decides who pays, for what, and what each customer can access, while billing turns that into invoices and collects payment. Billing works after usage happens, so the decision about whether a request is allowed has to live in the product.
The main risks of product monetization are choosing the wrong value metric, pricing below the cost to serve, and frustrating users with limits that feel arbitrary. For AI products, the biggest risk is usage that runs past a customer's limit because the check happened after the compute was spent.
AI companies monetize their products mostly through usage-based pricing, credits, or hybrid plans that pair a subscription with included usage. These models track the cost of each request, which flat per-seat pricing can't do on its own.