An Introduction To Pricing Models
Choosing the right licensing model is one of the most important decisions when commercializing software.
It affects not just how you charge customers, but also how you design your product, enforce access, prevent misuse, and scale revenue over time.
From a business perspective, licensing determines:
- How predictable your revenue is
- How easy it is to upsell or change pricing
- How well pricing aligns with customer value
From a technical perspective, licensing affects:
- How access is enforced in the application
- How complex validation logic becomes
- How easily pricing and features can evolve
- How well you can prevent unauthorized usage
Common Software Licensing Models Covered In This Article
This article provides a practical overview of the most widely used licensing models in commercial software:
- Perpetual (Try-and-Buy): One-time payment for permanent access, often combined with trials or maintenance periods.
- Subscription: Recurring payment with continuous access and support for feature-based plans.
- Usage-Based (Pay-per-Use): Pricing based on how much the software is actually used.
- Node-Locked & Floating (Concurrent): Licenses tied to machines or shared across teams via a central pool.
- Pay per Installation: Pricing based on the number of deployed instances or installations.
Each model has different business trade-offs and technical implications depending on your product type and customer segment.
Please note that all of these licensing models are supported by the Devolens licensing system.
Perpetual (Try-and-Buy)
What It Is
The customer pays a one-time fee and gets permanent access to the software, often after a limited trial period.
Typical business use cases include desktop software, engineering tools, creative software, on-premise applications, among others.
Business Benefits
- Simple to understand and sell
- One-time revenue per customer
- Works well when updates are infrequent
Technical Implications
Perpetual models usually rely on:
- Node-locked licenses (one license per machine)
- Or floating licenses (shared across a network)
- Optional expiry for maintenance or upgrades
This model works well for applications that are installed locally and don’t require continuous online validation.
When It's Not Suitable
This model is usually not a good fit for products that require continuous updates, frequent feature releases, or ongoing operational costs. It also becomes harder to sustain if long-term support, cloud infrastructure, or regular compatibility updates are part of the offering.
→ Read Perpetual licensing docs
Subscription Licensing
What It Is
Subscription licensing is where customers pay a recurring fee (monthly or yearly) to retain access.
Typical business use cases include, professional tools, plugins and extensions, SaaS-like desktop software, SDKs, developer platforms, and more.
Business Benefits
- Predictable recurring revenue
- Easier to lower entry barrier
- Supports long-term customer relationships
Technical Implications
Subscriptions require:
- Continuous license validation
- Handling renewals and expirations
- Clean access revocation when payments stop
This model also enables feature locking, where different plans unlock different functionality inside the same application.
From a technical standpoint, this usually means:
- Checking permissions at runtime
- Enforcing limits via license metadata
- Supporting upgrades and downgrades
When It's Not Suitable
Subscriptions are less suitable for products that are rarely updated, used infrequently, or expected to work fully offline without any form of ongoing validation. In these cases, customers may resist recurring fees and prefer a one-time purchase instead.
→ Read blog post on Subscriptions
Usage-Based (Pay-per-Use)
What It Is
The usage-based model is where customers are charged based on how much they use the product.
Business use cases that are common are APIs, developer tools, infrastructure software, and data processing tools, among others.
Business Benefits
- Pricing aligns closely with value
- Scales naturally with customer growth
- Low friction for small customers
Technical Implications
Usage-based models require:
- Reliable usage tracking
- Periodic reporting or syncing
- License limits that change dynamically
This is often combined with subscriptions (base fee + usage).
From an engineering perspective, this introduces:
- Metering logic
- Event tracking
- Enforcement based on quotas
When It's Not Suitable
Usage-based pricing can be a poor fit when usage is difficult to measure reliably, highly variable in unpredictable ways, or tightly coupled to internal system behavior. It may also be challenging for customers who require predictable costs for budgeting.
Node-Locked & Concurrent (Floating) Licenses
What They Are
Node-locked and concurrent licenses define how licenses are assigned and enforced, rather than how customers are billed.
- Node-locked: A license is tied to a specific machine or environment.
- Concurrent (floating): A fixed number of licenses are shared across multiple users or systems.
These two approaches are often combined with either perpetual or subscription pricing.
Typical Business Use Cases
- Engineering tools
- CAD and simulation software
- Scientific and research applications
- Enterprise desktop products
- Offline or on-premise software
Business Benefits
- Node-locked:
- Simple enforcement
- Reduced license sharing
- Works well in offline environments
- Simple enforcement
- Concurrent:
- Efficient license utilization
- Suitable for teams and departments
- Higher perceived enterprise value
- Efficient license utilization
Technical Implications
Node-locked licenses usually rely on:
- Machine identifiers or hardware fingerprints
- Environment binding (device, VM, container)
- Local validation for offline usage
Concurrent licenses typically require:
- Central license server or cloud validation
- Session tracking and timeouts
- Automatic release and reallocation logic
From an engineering perspective, concurrent licensing introduces more complexity, but enables flexible access for teams and organizations.
When They Are Not Suitable
Node-locked licensing is not ideal for highly dynamic environments where machines change frequently, such as cloud-based deployments or short-lived virtual instances.
Concurrent licensing is less suitable for products used by individuals rather than teams, or in environments where continuous connectivity to a license server cannot be guaranteed.
Pay per Installation
What It Is
The pay-per-installation model is where customers pay based on how many installations or deployments they run.
This is common among embedded software, OEM products, SDKs/libraries, and white-label solutions.
Business Benefits
- Pricing scales with distribution
- Works well for resellers or integrators
Technical Implications
This requires:
- Tracking installations
- Unique instance identifiers
- Validation per deployment
It’s common in B2B and embedded scenarios where software is redistributed.
When It's Not Suitable
Pay-per-installation models are often a poor fit when deployments are automated, ephemeral, or difficult to track accurately, such as in containerized or serverless environments. They also work less well when customers expect unlimited internal deployments under a single agreement.
→ Read blog post on the Pay-per-installation model
→ Read Pay-per-installation docs
Choosing the Right Model
There is no single “best” licensing model.
In practice, most software companies end up combining several:
- Subscription + feature locking
- Perpetual + node locking
- Usage-based + base subscription
- Concurrent licenses for enterprise customers
The right choice depends on:
- Application type (desktop, SDK, IoT, plugin)
- Customer segment (individuals vs teams)
- Deployment environment (online vs offline)
- How pricing is expected to evolve
Implementing Licensing in Practice
All of these models require some form of licensing infrastructure.
That usually means:
- Integrating with a payment provider and CRM
- Creating and validating licenses
- Enforcing access in the application
- Handling upgrades, downgrades, and expirations
This can be built internally, but many teams choose to use a dedicated licensing platform instead.
With Devolens, software teams can:
- Implement any of the models above
- Combine pricing and licensing logic
- Support online and offline environments
- Manage licenses through a dashboard and API
- Fully automate licensing
This allows teams to focus on product development instead of maintaining licensing infrastructure.
Get Started with
Devolens Today
Join the +500 customers and industry-leading software companies who have already chosen us as their software licensing system.
