Why Licensing + Payments Matter

If you sell an engineering tool, simulation suite, or developer SDK/API, you need two things:

‍

1. a way to get paid the way you price (seats, modules, usage, or a mix), and
   ‍
2. a licensing system that enforces those terms - across desktop apps, headless servers, CI/HPC clusters, and even offline/edge environments.

‍

Options: Roll-your-own / Vendor-locked Billing vs. Devolens

Roll-your-own

‍

• Total control, but you must build/maintain: key issuance, per-module entitlements, usage metering (requests, core/GPU hours), floating seats, offline tokens, audits, and migration paths.
  ‍
• Costly to scale across on-prem, clusters, and customer environments.

‍

Cloud/vendor billing only

‍

• Fast to start, but plan logic and metering are provider-defined; per-module licensing, tenant overrides, and offline/air-gapped cases usually need extra systems.
  ‍
• Hard to unify desktop tools + SDKs + APIs under one entitlement model.

‍

Devolens (third-party licensing)

‍

• Use any payment processor or sell via PO/invoices.
  ‍
• Models out of the box: per-seat, floating/concurrent, per-module/feature, usage-based (requests, jobs, core/GPU hours, credits), subscriptions, trials.
  ‍
• Offline capable with signed tokens; optional on-prem components for secure labs and factories.
  ‍
• Works across desktop, SDK redistribution, APIs, CI/HPC, and embedded/edge.
  ‍

Tip: Keep your existing billing. Let Devolens be the licensing & entitlements layer that your apps, SDKs, and services all trust.

Implementation: License & Usage Verification

‍

• Model your product once: seats, modules/solvers, limits (e.g., API calls, jobs, core/GPU hours), and trial rules.
  ‍
• Distribute entitlements per customer/tenant with online activation or offline tokens (time-boxed).
  ‍
• Check entitlements at app start, feature unlock, or per job/request; meter usage (soft or hard caps), and sync changes via webhooks.
  ‍
• HPC & CI: silent activation for build agents; time-limited leases for cluster nodes; idle timeouts recycle seats automatically.
  ‍

Most teams get a first feature licensed in about an hour, depending on the codebase. Below is a simple example in C#. You can read more in the key verification tutorial.

‍C# example (simplified):

‍

var licenseKey = "GEBNC-WZZJD-VJIHG-GCMVD"; // <--  remember to change this to your license key
var RSAPubKey = "enter the RSA Public key here";

var auth = "access token with permission to access the activate method";
var result = Key.Activate(token: auth, parameters: new ActivateModel()
{
    Key = licenseKey,
    ProductId = 3349,  // <--  remember to change this to your Product Id
    Sign = true,
    MachineCode = Helpers.GetMachineCodePI(v: 2)
});

if (result == null || result.Result == ResultType.Error ||
    !result.LicenseKey.HasValidSignature(RSAPubKey).IsValid())
{
    // an error occurred or the key is invalid or it cannot be activated
    // (eg. the limit of activated devices was achieved)
    Console.WriteLine("The license does not work.");
}
else
{
    // everything went fine if we are here!
    Console.WriteLine("The license is valid!");
}

Console.ReadLine();

Benefits You Get With Devolens

‍

1. Per-module licensing without multiple builds - unlock solvers, toolchains, and add-ons via entitlements.
   ‍
2. Usage metering that fits engineering reality - per run, request, job, core/GPU hour, or custom counters.
   ‍
3. Works offline & on-prem - air-gapped labs, factories, and field devices stay productive with signed tokens.
   ‍
4. HPC/cluster-ready - floating seats, node leases, and CI-friendly activations.
   ‍
5. B2B-ready operations - admin portals, seat transfers, audit logs, SSO-friendly flows.
   ‍
6. Payment-agnostic - connect your existing processor or invoice enterprises directly.
   ‍
7. Analytics & control - activations, usage, versions, renewals, and policy automation in one place.
   ‍

Examples

‍

• CFD/FEA suite: Base edition + solver modules + HPC packs measured in core-hours; labs use floating seats with node checkout.
  ‍
• Computer Vision SDK: Per-developer seats + per-app redistribution rights; usage-based requests for cloud inference; offline tokens for factory lines.
  ‍
• Embedded/industrial toolchain: Node-locked per workstation; 90-day offline tokens exchanged via secure file; per-module compilers.
  ‍
• Engineering API for developers: Tiered plans with rate limits, burst allowances, and paid overages; per-tenant overrides for enterprise.
  ‍

FAQ

Can we license per module or solver?
Yes. Define modules as features and grant them per plan or per customer - no extra installers.

Do you support usage-based pricing (requests, jobs, core/GPU hours)?
Yes. Meter events via API or batch; enforce soft/hard limits and bill on schedule.

How do floating seats work for clusters and labs?
Nodes check out a lease; idle timeouts recycle seats automatically. Scope pools per site or per customer.

Will it work offline or in air-gapped labs?
Yes. Issue signed, time-limited license tokens; set renewal windows that match your operations. Optional on-prem license components are available.

Can we redistribute an SDK to our customers’ apps?
Yes. Grant per-developer seats and per-app redistribution rights; keys can be scoped to app IDs and environments (dev/test/prod).

Can we keep our current billing provider?
Absolutely. Devolens is payment-agnostic; it acts as your entitlements source of truth.

How long does first integration take?
Teams often stand up a first licensed feature quickly (customer-reported; varies by codebase).