This post is the introduction to a short technical series exploring how licensing works in Umbraco packages — including concepts like signing, verification, and how to build a secure, developer-friendly licensing system yourself. We’ll cover the principles step by step, and while our package Rivlo Licensing already provides a free implementation of all these ideas, the goal of this series is to explain the foundations clearly so you can understand or build your own approach if you prefer.

If you’ve ever released an Umbraco package - even a small one - you’ll know the strange mix of excitement and vulnerability that comes with it. You share something you’ve built, you hope it helps people, but you quietly wonder whether you’ll have the time to keep improving it.

When I first started building tools for client projects, licensing wasn’t even on my radar. Most of what I created was bespoke: one-off utilities, integrations, or helpers designed specifically for a client’s site. Everything was delivered under contract, billed as part of the work, and never intended to be reused elsewhere.

It was only later, when I realised that some of these tools could genuinely help other teams, that the picture changed. Then, I wasn’t just building custom utilities — I was shaping them into reusable packages. Installable ones. Documented ones. Supported ones. That’s when licensing becomes something you actually need to think about.

Like many early-stage creators, I didn’t have the budget for a commercial licensing platform. They’re powerful, but usually built with larger teams and more complex infrastructures in mind. I needed something simple, reliable, and sustainable - without derailing development of the actual products.

What surprised me most was how little practical guidance existed for building a lightweight, secure licensing system in .NET or Umbraco. It’s clearly a common requirement, but there’s not much information out there. Or maybe I was just looking in the wrong places!

So I decided to build a system that solved my own needs, and then package it so others didn’t have to reinvent the wheel. That’s how Rivlo Licensing began: as a developer-friendly, cryptographically secure licensing system that anyone can use.

And because every developer should have access to a solid licensing foundation, regardless of budget:

Rivlo Licensing is completely free.

Not as a teaser, not as a restricted trial — free, because it genuinely helps the ecosystem.

A quick acknowledgement for the Umbraco community

Before we go deeper into licensing, it’s important to recognise something fundamental about Umbraco:

A huge amount of the ecosystem is powered by people giving their time, skills, and ideas freely.

Small packages, clever extensions, quality-of-life improvements — all shared because somebody wanted to help others build better sites. RivloTools absolutely stands on the shoulders of that generosity, and some of our own tools are free for the same reason: to give back.

Of course, there are notable exceptions in the Umbraco ecosystem:

Umbraco itself is open-source, but supported by a successful commercial business behind it. And tools like uSync provide an absolutely extraordinary amount of free, professional-grade functionality - backed by consulting work and optional paid add-ons.

Those models are brilliant, but they aren’t models that every freelancer or small development team can replicate.

This can lead to a dilemma for consumers:

Open-source contributions are hugely valued, but sustainability matters too.

Why licensing matters in practice

Licensing isn’t actually about restriction. It’s about creating fairness and confidence for everyone involved.

Without clear licensing, several problems emerge:

They might not know how many domains a package can be used on, whether it’s per-installation or per-project, or whether a licence is required at all.

Even small fixes and compatibility patches take time, and without a sustainable model, many packages quietly fade away.

If they’re not sure a tool will exist or be supported in the future, they can’t commit to using it for business-critical work.

That uncertainty creates friction whereas licensing, done well, removes friction.

Why licensing is fair — not a barrier

It’s perfectly reasonable for businesses and individuals to expect some level of payment for ongoing work.

Not everyone can afford to give away updates, fixes, support, and planning time for free - nor should they be expected to. Licensing exists to make that work sustainable.

Many users understand this. Often they prefer a paid product, because payment signals stability, longevity, and responsibility.

So, licensing isn’t about gatekeeping. It’s about enabling everyone - developers, agencies, and clients - to work with confidence.

Why we built Rivlo Licensing (and why we released it for free)

When RivloTools started to take shape, I needed a licensing system that would:

Many existing licensing systems are excellent, but they often come with:

Those models are totally valid, but they weren’t suited to the early stages of RivloTools — or to the needs of many independent developers.

So Rivlo Licensing was created to fill that gap: simple, modern, developer-friendly, and easy to adopt.

Releasing it for free was a deliberate choice. Whether someone is building a commercial add-on, a hybrid freemium package, or a community project with optional upgrades, I think they deserve access to a solid, trustworthy licensing foundation.

What’s coming next in this series

This post covers the “why”. Next, we move onto the “how”, aka the interesting bit!

Part 2 — Cryptography basics (without the jargon)

We’ll demystify signing and verification in a way that’s actually clear and approachable.

Part 3 — How to generate and sign licence files in .NET

A real, working example you can adapt for your own projects.

Part 4 — Validating licences in your Umbraco package

Clean, reliable validation logic integrated into your package.

Part 5 — Common licensing pitfalls and how to avoid them

Trials, renewals, offline checks, domains, versions — the real-world challenges and how to handle them.