//Template License

Last updated September 22, 2026

Template & Golden App License

UpliftOS keeps a shelf of finished applications — we call them golden applications — and you can take one and make it yours. This document covers what you get when you do: the license to the code, what the copy actually is, who owns what you change afterwards, and how updates from us reach you.

It is a companion to App Ownership & License, which governs your application as a whole. Where the two overlap, they say the same thing on purpose. Where this document goes further, it is because forking has mechanics that ownership in general does not.

One sentence first: the copy is yours to keep, and we never write to it.

1. What Can Be Forked, and What Cannot

The platform sorts every application into a kind, and the kind decides forkability:

  • Golden applications are forkable. They are our shelf stock — complete, working applications we maintain, which exist to be taken.
  • Applications you built — in App Factory, or connected from your own repository — are not forks of anything. They are covered entirely by App Ownership & License.
  • Platform surfaces are not forkable. These are the consoles that make up the product itself: App Factory, Agent Studio, the administrative surfaces, the Marketplace.
  • Products are not forkable. SecOps, ComplyOps and the other instruments you subscribe to are run by us, and a forked copy of a compliance instrument would attest to nothing.

This is not a commercial restriction dressed up as a technical one. Forkability is a property recorded on each application, and the two non-forkable kinds have no fork path at all.

2. The License

Where your application starts from a golden application or a template, we grant you a non-exclusive, worldwide, royalty-free, perpetual and irrevocable license to use, modify, run, deploy, distribute and commercialize that code as part of your application.

We assign nothing. The golden application itself — the one on our shelf, and every later version of it — stays ours. What you receive is a license to the copy, which is all you need to do everything above.

The license is perpetual and it survives. It does not end when your subscription does, it does not end if we withdraw the golden application from the shelf, and it does not end if we stop offering the product entirely. Code you have is code you keep.

Your changes are yours alone. Everything you add, rewrite or delete after the fork is your work, owned by you outright. We take no assignment of it, no license over it, and no right to reuse it. We do not read your fork to improve our golden applications, and we do not copy your features back into the shelf.

3. The One Restriction

You may not extract the template's code and redistribute it as a template — as a starter kit, a scaffold, a boilerplate, or a development platform for other people to build from.

To be precise about where the line sits, because the difference matters and it is not obvious:

  • Permitted: running your application, selling it, licensing it to your customers, listing it on the Marketplace, open-sourcing it, selling the company that owns it, handing the whole repository to a new provider.
  • Not permitted: repackaging what we gave you so that others can fork it the way you forked ours.

The test is what the recipient does with it. Someone using your application is fine, however they pay for it. Someone using your copy as their own starting point is the thing this section prohibits.

This is a contractual restriction, not a technical control. Nothing in the platform inspects a repository to enforce it, and we do not scan your code looking for violations. We are telling you the rule rather than policing it.

4. What a Fork Actually Is

Forking is a copy, made once, at a fixed point. Specifically:

  • We read the golden application's files at a pinned version — a specific released tag, not whatever happens to be current.
  • We create a brand-new repository belonging to your organization, and write that entire file tree as a single first commit.
  • You get the standard set of environments — development, staging and production — the same ones any application on the platform gets.

Two consequences follow, and both are deliberate:

Our development history does not come with it. Your repository begins at one commit reading Golden <App> v<X.Y>. Our internal commit messages, our abandoned attempts and our reverts are not part of what you receive. This is a one-way door: the link back to our history exists in our records, not in your git log.

Your data is not touched. Forking copies code. It does not move, copy, migrate or delete anything in your database, and neither does reversing it.

5. Updates Reach You Only When You Take Them

We keep developing golden applications after you fork one. None of that reaches your repository unless you ask for it. There is no automatic update, no background merge, and no mechanism by which we write to a repository you own. Your fork stays exactly as you left it for as long as you like.

When you want to see what has changed, the platform performs a real merge of the upstream release against your code and reports one of three answers:

  • Clean — the update applies without touching anything you changed.
  • Conflicted — it collides with your work, and we name the specific files.
  • Unknown — we could not complete the comparison, and we say so.

That third answer exists because the alternative is worse. A comparison that cannot run and reports "clean" anyway would be a lie that costs you a broken deployment. If anything prevents us from answering honestly, you get unknown and the reason, never an optimistic guess.

Taking an update is your decision and your merge. Deciding not to take one is a supported way to run, indefinitely. We do not withdraw support, degrade your application, or stop it running because it sits behind the current release.

6. Our Roadmap Is Not a Promise

Some golden applications publish a roadmap so that you do not spend a month building something we are about to ship. It is offered for exactly that reason and no other.

Nothing on a roadmap is a commitment. Items change, slip and get dropped. Do not treat a roadmap entry as a delivery date, a specification, or a reason to defer work you need. Nothing in it forms part of any agreement between us, and it does not modify what we owe you under your subscription.

7. Third-Party Components

Golden applications are built on open-source software, and that software comes with the copy you receive. Those components are governed by their own licenses, not this one, and nothing here grants or restricts rights their licensors have granted or withheld.

The dependency manifests ship inside the repository you receive, so the full list travels with the code. We do not maintain a separate inventory of those components or their licenses, and we do not undertake to notify you when one of them changes its terms.

8. Provided As-Is

A golden application is a starting point, not a certified product.

We provide it as-is, and we do not warrant that it is free of defects, fit for your particular purpose, compliant with any law or standard that applies to your industry, or suitable to run without review. Once you fork it, the code is in your repository, under your control, and you are responsible for what it does — including its security, its correctness, and its compliance with the rules your business is subject to.

Where your application handles regulated data, the Data Processing Addendum governs what we do with that data as your processor. It governs our handling; it does not certify the template's code, and forking a golden application does not make your application compliant with anything.

Nothing in this section limits anything we owe you under your subscription agreement, and it does not exclude liability that cannot lawfully be excluded.

9. Turning a Fork Back Off

You can stop using a fork and return to running our hosted copy of the golden application instead.

  • Your fork's repository is removed when you do this. Take a copy first if you want one; the source archive and repository transfer routes exist for exactly that.
  • Your data stays. Forking never moved it, so reversing the fork has nothing to move back. The hosted copy continues serving the same database.
  • The license in Section 2 survives, over any copy of the code you kept. Turning a fork off does not revoke rights you already have.

10. Changes to This Document

We will update this document as the fork mechanism changes. Material changes are notified the way our Terms of Service requires, and the date at the top always reflects the current version.

Questions about this document, or about a specific template's licensing, go to [email protected].

11. Related Documents