Category: License Models

License Models and techniques to license your software.

Software Licensing Best Practices - Software License Entitlements

Software Licensing Best Practices-Part 4

For software vendors, the most valuable aspect of using a license manager is the freedom to define exactly how your customers buy and use your software products. You can match the attributes of your licenses to the precise needs of your customers and markets. Equally valuable is the ability to address unusual opportunity-specific requirements from your biggest and most important customers or new technology partners.

Read more

Using an Activation Server as a License Manager

Do You Really Need a License Manager?  Or can you use an Activation Server as a License Manager?

In certain circumstances, you could use an Activation Server as a license manager.

This would be the case for very simple, straightforward node-locked licensing.  For example, an app that runs on a phone or a tablet (or a simple application that runs on the desktop).   Instead of integrating a license manager, you add a call to activate the license, and the activation server performs the initial activation on the first request, and verifies that the license is activated on subsequent requests.

Advantages:

  • You avoid the cost of a license manager.
  • The code is easier to integrate
  • The software footprint in your code is smaller

Disadvantages:

  • Your application must contact the activation server on every invocation.
  • The licensing models supported are quite simple – nodelocked, uncounted only

How would this work?

Let’s put aside the issue of how the activation keys are created in the first place.  There are a variety of ways this is accomplished, depending on your business rules.

When your application runs, you do the following:

  • determine some unique charactistic of the device or computer.   If it is a phone, this might be as simple as the phone number or the device’s ethernet MAC address.
  • your software presents the activation key and the device id to the activation server and receive the status:
    • Not Activated previously -> the server records the device ID, and returns a success status.
    • Activated previously from this device -> the server returns a success status.
    • If the key was activated from another device, the status would be “key already used”.

It’s really as simple as that.  There is a single web services call to perform the initial activation and checks status later.

101 License Models – Metered License Models

A while ago, we wrote a blog post entitled 101 license models.  Since that time we followed up with posts on unrestricted license models, nodelocked license models, floating license models, and token-based license models.  In this post, we explore the fifth set of license models described in that post – the Metered License Models.

   Metered License Models

To review, a metered license model allow you to consume a resource when your program runs. Your customer can perform an action “N” times, or for a fixed amount of time.  These licenses are usable by anyone who can contact the license server.  Metered licenses can have any of the following attributes:

Ways to use Metered License Models

Metered licenses have 3 main uses:

  • counting the number of invocations of a product
  • keeping track of how long a product runs, or
  • counting events within a product (e.g. pages printed, database lookups, etc).

In the first case, the license server decrements the meter each time the product checks out a license.  For keeping track of how long a product runs, the server performs a decrement to the meter at a specified interval.  Finally, for counting events, your software would perform a checkout request when the event happens.

A metered license model gives you control over the software which isn’t available with nodelocked or floating licenses. Metered License Models provide true consumptive licensing.

101 License Models – Token-Based License Models

A while ago, we wrote a blog post entitled 101 license models.  Since that time we followed up with posts on unrestricted license models, nodelocked license models, and floating license models.  In this post, we explore the fourth set of license models described in that post – the Token-Based License Models.

   Token-Based License Models

To review, token-based licenses are a special case of floating licenses which allow aliasing of a license or multiple license checkouts per request.  These are usable by anyone who can contact the license server.  Token-based licenses can have any of the following attributes:

Ways to use Token-Based License Models

Token-based licenses are a special case of floating licenses, and they have 3 main uses:

  • packaging together a number of products and distributing a single license
  • creating an alias from one product name to another
  • allowing newer software to run and consume licenses distributed with older software (a special case of #1)

In the first case, packaging together a number of products, let’s say you have product a, b, and c.  Create static token-based licenses for each of a, b, and c which map to a checkout of “d”.  Now you distribute the “d” license, and all 3 products, a, b, and c can run with this license.  Different modes of operation are possible by changing the sharing attributes on the “d” license.

To create an alias, the token definition maps one license checkout request to a different request.  This is useful to transition a product’s license name.

For the 3rd case, a generic token name is the only license you deliver.  All products have token license definitions which map to the generic license name.  As you add new products, they use licenses which your customer already has, thus creating contention for these licenses (meaning increased sales).  This allows your customers to demo your new products while consuming existing licenses – no more free demos!

 

Policy in the License

Don’t paint yourself into the corner – use Policy in the License.

When you think about adding licensing to your software, you want the licensing software to “do the work” of licensing. You don’t want to write special code to handle the various business cases for your licenses.  When you put the policy in the license, you remove it from the application code.  This makes changes down the road much easier.

RLM allows you to request a license within an application without knowing what kind of policies are present beforehand. You need to do little to no manipulation of the licensing routines themselves.

With RLM, license policy is in the license keys, where it belongs. We call this “Policy in the License”.  So when your application requests a license, the license is granted is based on what licenses are found in the customer’s license pool.  This allows you to address ever-changing business rules by varying the type of license keys that you issue.

Keeping Pandora’s Box Closed

Legacy license managers open a Pandora’s Box by allowing applications to store arbitrary information in the license key. This is a mistake because it requires special programming in your application to retrieve, decode and process the data.   Your application then needs the logic necessary to implement the custom policy which the data specified. More importantly, this unfortunate design decision leads to the proliferation of incomprehensible license strings. Unpredictable license behavior across applications and across ISVs is the result. RLM supports new policies by enriching the syntax of the license to address new yet generally useful license policy options.  Here are a couple of examples of Policy in the License:

Token-Based Licenses

RLM has a simple yet elegant way to define one RLM license in terms of another. It is used in two common ways.

First, it can enable “token-based” pricing models where each of your products checks out a license for itself which results in license tokens checked out from a common pool.  Each product checks out a number of tokens equal to its relative value. Any number and combination of products can be used so long as the maximum number of tokens in the pool is not exceeded.

This model works especially well for companies that sell suites of related products that are used to various degrees during a project. As the project advances from one phase to another (Design, Test and Simulate), the mix of products used reflects the demands of that phase of the project. So you don’t sell a certain number of seats of each product.  Instead, the user determines the mix based on his needs.

This model also allows you to introduce new products to your customers easily since the new products consume the same licenses (tokens) that are already installed.

The other main use of token-licensing is to enable license alternates. This is the case where you sell a single product that consists of many separately licensable components (product and sub-product model).  If you sell product bundles at a special discounted price, then customers can purchase a combination of both the bundles and the components of the bundles in order to match their requirements. If a component license is unavailable, then a higher priced bundle license, if available, can be checked out to satisfy the request as a last resort.

Overdraft licenses

A token-based strategy can also address overdraft situations. In this case, when all the regular licenses are in use, overdraft licenses are consumed instead. If required, the overdraft licenses can have shorter term expiration dates so that they can be used only during a predetermined time window. And overdraft licenses are reported separately in the report log, so they are accounted for appropriately.

No changes to your application are needed to support token-based licensing – “the policy is in the license.”

WAN Licenses – use time zones to increase pricing options

Your biggest customers usually connect their geographically dispersed sites via a WAN. When they do that, they can share your floating licenses across the globe. For a variety of reasons you may want your licenses used only within a particular geographical area. With RLM, you can assign a “timezone” to the license to allow use of your software only in those zones. You could charge a higher fee for licenses that cover a wider geographical range, and less for restricted licenses.

Again, no changes to your application are needed to support WAN licensing when you use “policy in the license.”

101 License Models – Floating License Models

A while ago, we wrote a blog post entitled 101 license models.  Since that time we followed up with posts on unrestricted license models and nodelocked license models.  In this post, we will explore the third set of license models described in that post – the Floating License Models.

The Floating License Models

To review, floating licenses are the most commonly used license models.  These licenses can be used by anyone who can contact the license server.  The floating license models provide the richest set of license control. The floating license models we talked about are these:

Ways to use floating license models

Floating licenses are not generally locked to any machine – although they can be. They are served by a license server which is itself locked to the host where it runs.  In other words, in general floating licenses work anywhere, but only up to the maximum concurrent license count imposed by the server.  Floating licenses are the most popular licenses used by software publishers since they allow the maximum flexibility in pricing as well as day-to-day usage by end-customers.

The traditional, or “plain vanilla” floating licenses are by far the most popular of all.  They allow a software publisher to sell more valuable licenses (often at a higher price) as compared to node-locked licenses.  For the customer, the added flexibility to use a license on any client on their network provides significant extra utility and value, when compared to licenses node-locked to each client.

The other models listed are generally variants of the traditional floating license.  By adding these attributes to the license, additional restrictions apply.  Often a publisher will restrict the timezone where a license is available, or the platforms on which the software is allowed to run.

A named-user license is a special case of a floating license. It allows the customer to assign particular users to the licenses.  Over time, these users can be changed, but not too often. This gives the customer the flexibility of a floating license model, but restricts the usage to the names on the list only, not to the general user population.

Finally, license sharing (for example,  shared by host) allows multiple instances of the software while consuming a single license.  In the case of shared by host, multiple instances running on the same host would consume only one license.

We will explore the last two License Models (Token-based and Metered) in future blog posts.