Part I of After Scarcity, Before Sovereignty: Sovereignty Is Having an Exit, What If Work Became Optional?, and Globalization and the Problem of Exit.
I started self-hosting seriously around 2015, then mostly stopped between about 2018 and 2024 because reliability won out. Hosted services were easier to operate, easier to recover, and required much less attention.
That experience changed how I think about digital sovereignty. Rather than asking whether everything runs on hardware I own, I ask whether I can leave a service when I need to: can I move the data, replace the provider, and rebuild the service somewhere else?
The cloud won for good reasons
Self-hosting provides control, but it also means owning the operational burden: hardware, power, storage, backups, patching, monitoring, certificates, networking, failed drives, and recovery.
Power has become a more important constraint for me. My own setup mixes older SATA storage, SSDs, model storage and development data, but inexpensive hardware can be expensive to keep running, especially for AI workloads. Sometimes renting the service is the sensible thing to do.
I take a similar approach to storage. Nextcloud covers a large part of what I need from consumer cloud storage, but local capacity is only useful if recovery works. Important data still needs another copy somewhere else. Self-hosting without off-site recovery is just a different kind of dependency.
Email is a good example
Email cured me of a lot of self-hosting enthusiasm. Running an SMTP server is easy enough; running one that reliably delivers mail to Gmail, Outlook, corporate gateways, and telecom systems is not. Reputation, DKIM, SPF, DMARC, blocklists, spam filtering, backups, and availability all become operational responsibilities.
Earlier in my career I worked at LinuxMagic, which provides email infrastructure for ISP and telecom environments, so I had some exposure to what sits behind something most people experience simply as an inbox.
For critical email, I would rather pay somebody who is good at operating it. Proton is one option I like. It is Swiss rather than Canadian, but that still provides useful diversification from the large American platforms. ISP mail can also be a reasonable, deliberately boring alternative, but an address tied to an internet provider is harder to take with me when I switch providers. Using an address on a domain I control lets me move mail hosting without asking everyone to learn a new address.
DNS and regulation both help
I currently use Cloudflare for DNS because it is reliable and convenient, although I could also run an authoritative BIND server myself. What matters more is that I control the domain, which gives me a stable interface while the infrastructure behind it changes.
Moving a stateful service also involves databases, certificates, authentication and possibly replication or queues. Keeping the name independent of the machine still lowers the cost of moving.
There is a legal version of the same idea. The GDPR established stronger rights around portability and erasure in many circumstances. Those rights are not absolute, but the principle is useful: export should work, deletion should work, and migration should be possible.
An exit is stronger when it is supported both technically and legally.
Git is technically sovereign and socially centralized
Git is almost ideal for sovereignty because the repository itself is distributed. I can run Forgejo, keep mirrors, and move repositories without changing the underlying version-control model.
GitHub, however, has become part of the industry’s public infrastructure: recruiters, open-source communities, issues, releases and CI all depend on it. I think of it as the public storefront while keeping the repository portable. An independent Forgejo instance can remain a mirror or alternate origin, and Canadian projects such as CanForge now provide another option. Connexxia describes CanForge as Forgejo-based sovereign Git, CI/CD, and container-registry infrastructure within its Sovereign One stack. Its broader builder and marketplace are still being rolled out, so I would treat the surrounding platform separately from the underlying Git hosting capability.
A Git mirror preserves the repository and its history, including tracked CI workflow files, but not the whole forge. Issues, access permissions, CI secrets, runners, release assets, and project metadata need separate exports, backups, or a migration plan. A portable repository is necessary, but it is not a complete recovery strategy.
Rebuildability matters
My home infrastructure is centred around a machine I call Dubnium. I started with inexpensive parts, and expect the GPUs, storage and perhaps the number of machines to change as workloads grow.
Much of Dubnium is described with NixOS, so the useful asset is the ability to reproduce its behaviour on different hardware. Declarative configuration is a starting point, not proof of recovery: periodically restoring data and bringing up a service on another machine or provider is how I can test whether an exit actually works.
I think of sovereignty in four layers:
Scheduled jobs, small APIs, file storage and CI runners are reasonable candidates to bring home when operating costs permit. GitHub can remain the public control plane while some CI execution happens on infrastructure I own.
AI is harder
AI is probably the hardest dependency for me to reduce. I run models locally on Dubnium, and they are useful, but they are not always competitive with the strongest hosted models. Giving up frontier models entirely would still carry a real productivity cost, so I treat local inference as one execution option rather than a complete replacement.
The architecture I prefer is a supervisor/specialist model, which I have also been exploring in the Dubnium orchestration design:
The boxes describe roles, not vendors. The supervisor might use OpenAI today, Anthropic tomorrow, Cohere, Augure, or eventually a local model. A specialist for coding, RAG, MIDI, or document processing can also be local or hosted depending on cost, capability, privacy, and latency.
Smaller specialist models may be cheaper, faster or better suited to narrow tasks. More importantly, switching the supervisor need not replace the rest of the system.
I am interested in moving more of my ChatGPT usage toward Augure. Its Canadian-hosted models and OpenAI-compatible API make experimentation comparatively cheap, but replacing an API endpoint is easier than replacing an integrated product. Reasoning quality needs to be evaluated against representative coding, architecture, research and tool-use tasks.
ChatGPT’s Gmail, Google Calendar and GitHub integrations matter to me as much as the model. I have not yet found documented Augure equivalents, and recreating them would introduce authentication, authorization, security and maintenance work. This makes the transition a migration rather than a switch: move bounded workloads first and retain ChatGPT where it offers a meaningful advantage.
Sovereignty can exist at more than one scale
Dubnium illustrates personal-scale sovereignty, but not everyone needs to operate their own infrastructure. There is a useful community scale between a workstation and a hyperscale provider. Vancouver’s Z-Space Local AI Collective is an early place-based example: members pool resources to operate locally hosted AI infrastructure, access models through a shared gateway, experiment with community knowledge systems, and keep inference in Vancouver. It is still a prototype rather than proof that every governance or security problem is solved, but the model matters. Shared infrastructure can be locally operated without requiring every participant to own a GPU server.
Another example worth watching is PolarGrid, an independent Canadian AI infrastructure startup building a distributed GPU inference network. Its approach places inference closer to users through geographically distributed GPU sites. That is a commercial edge-compute model, distinct from the community-owned infrastructure at Z-Space.
A community network of spare GPUs, loosely comparable to SETI@home for AI, would be another possible model, not a description of PolarGrid’s service. It raises harder questions around privacy, trust, verification, model distribution, latency and malicious nodes. What interests me is whether these approaches make compute more distributed and providers more replaceable.
That suggests a spectrum rather than a binary choice:
The sovereign property is not the box on the left. It is the ability to choose the appropriate scale for a workload without surrendering the ability to move again later.
There is a national ecosystem dimension too. The Linux Association of Canada lists open-source procurement, open standards, and digital sovereignty among its government-relations objectives. In September 2026 it also reported more than 5,300 downloads from its Canadian open-source software library. That shows practical interest in a Canadian open-source ecosystem, not proof of sovereignty. Source availability and open standards help make systems inspectable and portable, provided licensing, documentation, data portability and operational capability support them.
Credentials are part of sovereignty
Keeping the AI control plane local also helps keep credentials out of places that do not need them. A bounded project container can inspect a repository, edit files and run tests without inheriting my SSH agent, private keys, broad GitHub tokens or host-control sockets.
The next step in Dubnium is to separate local repository mutation from remote repository authority:
In this design, remote operations would be performed by a narrow host-side
worker using an exact repository identity and a short-lived, repo-scoped
credential. It need not enter the model context, worktree, container environment
or a forwarded SSH_AUTH_SOCK. Changing the model provider should not silently
change who can mutate a repository.
Location is not the same as control
A Canadian data centre is useful, but it does not automatically mean Canadian sovereignty. A foreign company can operate servers in Canada and keep the data physically here. That solves a residency problem, but it does not necessarily solve a control problem.
Contracts and privacy rules matter, but under sanctions, emergency powers or war, practical control can matter more than residency. A server in Toronto does not change who ultimately controls the company.
| Question | Concern |
|---|---|
| Where is the data? | Residency |
| Who can ultimately control it? | Sovereignty |
For ordinary workloads, residency may be enough. For infrastructure that needs to remain available through geopolitical disruption, local storage without local control may not be enough.
A current Dubnium provider-qualification thread uses Augure as a concrete test case. A Canadian AI provider can improve residency and jurisdictional fit, but “Canadian” is not sufficient evidence by itself. Inference location, retention, subprocessors, cross-border failover, and contractual guarantees still have to be checked.
Network access is another exit
I use Tailscale while keeping the system portable enough to move toward self-hosted NetBird, plain WireGuard, or another control plane. A private VPN lets me administer services without exposing them publicly; a commercial browsing VPN changes the network and operator I trust. Neither gives me control over the destination service.
| VPN use | What it contributes | Remaining dependency |
|---|---|---|
| Commercial browsing VPN | Hides my source IP from destinations and encrypts the hop from my device to the VPN endpoint. | The VPN operator can see connection metadata; accounts and cookies can still identify me. HTTPS still protects web content beyond the VPN endpoint. |
| Private VPN or mesh | Connects devices and limits which services need public exposure. | Device identity, access policies, coordination, and a recovery path if access fails. |
| Self-hosted VPN | Puts the endpoint and its configuration under my control. | Hosting, reachability, patching, and key management remain my responsibility. |
Tailscale encrypts device-to-device traffic, while its hosted coordination service helps devices discover each other and manage identity and policy. Established connections can often continue through a coordination outage, but onboarding, key changes, policy updates, and some reconnection paths still depend on that service. For sovereignty, the test is whether I can replace the coordination dependency or recover access another way—not just whether the traffic is encrypted.
I am also interested in a simple policy switch for public infrastructure:
| Mode | Purpose |
|---|---|
| Global | Normal public access |
| Canada only | Coarse geographic reduction of exposed surface |
| Private only | Administrative or private-mesh access only |
A Canada-only mode would be a contingency firewall policy, not authentication. GeoIP sees a connection’s apparent source, not the person: a Canadian VPN exit or compromised host could bypass it. It can still reduce exposed network surface without depending on a cloud or VPN provider for the policy.
Disconnected communication is another exit
The internet itself is a dependency, which is why I have been thinking about Meshtastic as a fallback communications layer. It can carry low-bandwidth traffic over LoRa without cell towers or an internet connection, including encrypted channel traffic when the participants share the appropriate keys.
Meshtastic publishes packages for OpenWrt-supported routers. With compatible LoRa hardware, a router could bridge local Wi-Fi or Ethernet services to the mesh. Airtime is scarce, so the interesting possibility is not bulk transfer but messages larger than a single packet that survive intermittent connectivity and arrive in pieces without losing their identity.
Meshtastic is already experimenting with some of those primitives. Its Store & Forward++ port is specifically described for Native Linux nodes as providing a “Git-style chain of messages.” The current protobuf defines message, commit, and root hashes, chain queries and link requests, plus first-half and second-half fragment messages. That is useful precedent, but it is not yet a general large-object transport.
For a larger distributed message, I would put another layer above the radio:
A signed manifest could identify the author, ordering, chunk hashes, expiry and an optional erasure-coding profile. Recipients could verify opportunistically forwarded pieces without trusting individual relays. Content addressing and cryptographic linkage are useful here; a Merkle DAG or hash-linked log is a better fit than a conventional blockchain.
The IETF Bundle Protocol provides the mature precedent: a delay-tolerant, store-carry-forward overlay for intermittent links with fragmentation and reassembly. Meshtastic could be one constrained transport underneath that architecture.
As a sovereignty property, the appeal is graceful degradation: communication can fall back from the global internet, to local IP, to low-bandwidth radio, while message identity and integrity remain stable.
Where I ended up
Some dependencies are harder to replace than others. Apple and Google provide capable phone ecosystems, for example, while alternatives involve meaningful trade-offs. I need to know which dependencies are acceptable and which require a credible exit.
I want data I can move, backups I can restore, machines I can rebuild, domains I control, services behind interfaces I can replace, AI roles I can move between providers, credentials held only where they are needed, and communications that can degrade gracefully when ordinary infrastructure disappears.
I will self-host where that makes sense and use commercial services where they are better at the job, including American services when they are genuinely the best option. The important part is making sure convenience does not quietly become dependence.
