Proof of Concept Licensing with Devolens

When you share an early prototype or trial — with customers, partners, or internal stakeholders — you usually need two things:

‍

• Control who can access the product
  ‍
• Avoid building throwaway systems you’ll have to replace later
  ‍

Devolens lets you add licensing to your proof of concept in a way that works today and remains usable when the product moves into production.

The same integration can be reused for trials, paid plans, subscriptions, and more — without rewriting your licensing logic.

‍

Typical PoC Licensing Scenarios

Teams usually add licensing to a PoC when:

‍

• A customer wants to test paid features
  ‍
• Access must be restricted during evaluation
  ‍
• A demo needs real usage limits
  ‍
• Internal stakeholders require basic controls
  ‍
• The product is likely to become commercial
  ‍

At this stage, many teams consider quick solutions like hard-coded keys or simple scripts. These work initially — but rarely survive long-term.

‍

Common Approaches (and Their Tradeoffs)

‍

Ad-hoc Sharing (Zip Files, Builds, NDAs)

Fast to get started, but:

‍

• No expirations
  ‍
• No revocation
  ‍
• No feature control
  ‍
• High risk of uncontrolled distribution
  ‍

Best suited for pure demos, not for real evaluation.

‍

DIY PoC Gating

Hard-coded keys or simple checks can feel reasonable:

‍

• Minimal setup
  ‍
• Full control
  ‍
• No dependencies
  ‍

But these approaches typically lack:

‍

• Offline support
  ‍
• Seat or device limits
  ‍
• Analytics
  ‍
• Migration path to paid plans
  ‍

Most teams end up replacing them later.

Devolens (Dedicated Licensing Platform)

With Devolens, teams can:

‍

• Set trial duration and expiration
  ‍
• Control feature access via entitlements
  ‍
• Apply seat, device, or usage limits
  ‍
• Support both online and offline environments
  ‍
• Convert the same setup into paid plans later
  ‍
• Fully automate licensing from payment to distribution, renewal, and churn
  ‍
• Integrate licensing with payment providers and CRMs
  ‍

This makes the PoC behave like a small product — not a disposable prototype.

‍

How Licensing Works in a PoC

A typical PoC setup looks like this:

‍

• Create a product with trial rules (duration, features, limits)
  ‍
• Add a lightweight license check in your application
  ‍
• Share access using license keys or offline files
  ‍
• Revoke or extend access as needed
  ‍
• Convert trials to paid by updating entitlements
  ‍

The same installation can move from trial to paid without new builds or rewrites.

Teams often report first integrations in about an hour, depending on the codebase.

‍

Business Benefits at the PoC Stage

Even early on, production-ready licensing provides clear advantages:

‍

• No throwaway systems to replace later
  ‍
• Faster transition from trial to paid
  ‍
• Consistent access control across customers
  ‍
• Reduced engineering maintenance
  ‍
• Clear upgrade path for pricing models
  ‍

Instead of treating licensing as temporary, it becomes part of your long-term product infrastructure.

Technical Capabilities

Devolens supports licensing requirements that often appear even during PoCs:

‍

• Secure key generation and validation
  ‍
• Feature-based entitlements
  ‍
• Seat and device locking
  ‍
• Usage tracking and metering
  ‍
• Offline validation using signed, time-limited tokens or a license server
  ‍
• Version compatibility across releases
  ‍

This is especially useful for:

‍

• Desktop software
  ‍
• Developer tools and SDKs
  ‍
• Embedded or industrial systems
  ‍
• Plugins and extensions
  ‍

Where internet access cannot always be assumed.

‍

Implementation: License Verification

‍

Below is a simplified example of verifying a license in Python.

(Examples in other languages are available in the documentation.)

‍

RSAPubKey = "enter the RSA Public key here"
auth = "access token with permission to access the activate method"

result = Key.activate(token=auth,\
                   rsa_pub_key=RSAPubKey,\
                   product_id=3349, \
                   key="ICVLD-VVSZR-ZTICT-YKGXL",\  
                   machine_code=Helpers.GetMachineCode(v=2))

if result[0] == None:
    # an error occurred or the key is invalid or it cannot be activated
    # (eg. the limit of activated devices was achieved)
    print("The license does not work: {0}".format(result[1]))
else:
    # everything went fine if we are here!
    print("The license is valid!")

‍

Common Scenarios We Cover

‍

• Simulation suites (FEA/CFD/EM): editions + solver modules + HPC packs.
  ‍
• SDKs & developer tooling: per-developer seats, per-app redistribution rights, request-based pricing.
  ‍
• Embedded/industrial: factory-floor activation, field-service rekeys, and offline compliance windows.
  ‍
• APIs for engineers: tiered plans with rate limits and overage credits.
  ‍

Getting Started with Devolens

If your PoC already needs controlled access, it’s usually a sign that it’s more than just an experiment.

You can create a free account and experiment at your own pace — no production commitment required.

Our documentation page has detailed guides and code snippets for a quick and easy implementation so you can add licensing to your PoC that survives all the way to production and beyond.