Proposed principles · first draft

Seven principles for a sovereign website.

A sovereign website is a website you own and can move. These seven principles say what that means, in terms anyone can test a site against, whoever built it and however.

Status
Proposed, first draft, open for comment
Author
Dinis Cruz
Licence
Not yet set; for Dinis Cruz to decide
Source
What is a sovereign website

Why one small part matters

Owning a website is the easy part. Moving it is where it fails. Once there is a piece of proprietary technology in the middle, it does not matter how small it is: you cannot move the site. Nobody else can move it for you either, and you cannot even pay someone to, because they would have to rebuild that component first. A paid plugin, a platform's form handler, a hosting company's special function, an agency's private framework: any one of them is enough.

Lock-in also has more than one place to hide: where the domain is registered, the technology underneath, and the platform it runs on. A site that is portable in its code but registered in someone else's name is not sovereign. Nor is one in your name that only runs on one company's servers.

Sovereign is what a site is, not how it was built. A sovereign website could be made by hand; a Sovereign Agentic Website is one built and changed by agents. The principles hold for both.

A website is sovereign when

  1. 1 You own it.

    The site, its content and its history are in a repository in your name, and the domain is registered to you, at a registrar you chose.

    How to test it

    • Whose account holds the repository? It should be yours, not your builder's.
    • Can you see the full history of changes, not only the current version?
    • Look up who the domain is registered to, and at which registrar. Both should be you and your choice.

    It fails if any one of these is in someone else's name.

  2. 2 You can move it.

    It runs on any commodity host that can serve files, without changes.

    How to test it

    • Take the files the site is served from and put them on a different host that only serves files.
    • Does every page work there, without editing anything?

    It fails if the site needs changes, or a particular host, to run.

  3. 3 Nothing in the middle is proprietary.

    Every part it needs to build and run is open and commodity. If one part is not, the site is not sovereign, however small that part is.

    How to test it

    • List every part the site needs to be built and to run: the generator, the theme, each plugin, the forms, any functions, any feature of the host.
    • For each one, ask: is it open, and could someone else supply or rebuild it without the company that made it?

    It fails on the first part that is not. One is enough.

  4. 4 Its content and schema are open.

    Words, data and their structure are in open formats you can read without the tool that made them.

    How to test it

    • Open the site's content and data files without the tool that made them, for example in a plain text editor.
    • Can you read both the words and how they are structured: pages, fields, lists, relationships?

    It fails if the content, or its structure, can only be read through the original tool or an export format the vendor chose.

  5. 5 Anyone can change it.

    You, any developer, or your own AI, without asking the company that built it.

    How to test it

    • Could a developer you choose, who has never worked with your builder, make a change and publish it?
    • Could your own AI, pointed at the repository, do the same?

    It fails if a change needs the builder's permission, account, licence or private tools.

  6. 6 What works on it is bounded.

    Agents and tools that change it work inside a behaviour policy that says what they may touch.

    How to test it

    • Is there a written behaviour policy, in the repository, saying what each agent or tool may and may not change?
    • Do the agents and tools that change the site actually work inside it, with checks that refuse what it does not allow?

    It fails if what changes the site is limited only by what it can reach.

  7. 7 It is proven, not claimed.

    It is deployed, regularly, on more than one host, so that moving is a thing that already happened, not a promise.

    How to test it

    • Is the same version of the site live, or recently deployed, on more than one host?
    • Is there a record of those deployments, and are they repeated, not done once?

    It fails if moving has only ever been described, never done.

Where is your site? Sovereignty is not yes or no; it is how far you can move, on your terms. The maturity model places a site on six levels, from 0, rented, to 5, sovereign and proven.

The proof: one commit, every host

Principle seven needs a demonstration. The proposal is that every Sovereign Agentic Website should carry one: the same commit, deployed by one pipeline to many hosts. The hosts named for it are GitHub Pages, Cloudflare Pages, Netlify, Azure Static Web Apps, AWS S3 and CloudFront, Codeberg Pages in Germany, a European cloud's storage bucket, and a plain folder on your own computer served by any web server. Each host would get a short set of instructions, so that anyone can repeat it.

That pipeline does not exist yet. Only GitHub Pages is in use today. Whether such a site can also be built and served inside an AI's own sandbox is an open question.

Open for comment

These principles are a proposal, written to be argued with and improved. This is the first draft published here. The source of this page is in SovereignWebsite__Org on GitHub, where changes to it are made in the open.

What this does not claim

  • The principles are a proposal, first draft, not a standard.
  • The tests are a plain reading of each principle, offered to make them usable; they are open for comment too. Principle seven does not yet say how often counts as regularly.
  • The every-host pipeline does not exist yet; only GitHub Pages is in use today.
  • Sovereign, here, means owning a site and being able to move it. It is not a legal or certification claim.