Skip to content

Sovereignty in Distributed Compute (Why Laptops dont matter)

· 8 min

laptop workstation

When choosing a machine, you face the Trilemma Of Choice:

The Computing Constraint Trilemma#

  1. Portability - weight, battery life, form factor
  2. Performance - CPU headroom, GPU capability, thermal sustained load
  3. Economy - initial cost, maintenance burden, replacement cycle

You can pick two.

Most people choose portability + performance: a $4500 MacBook Pro that goes anywhere and handles heavy workloads - until the battery degrades, thermals throttle sustained loads, or soldered components fail. Then you get the privilege of replacing the entire machine.

I chose differently: I separated the constraints across two devices.

The laptop thus becomes a thin client to the workstation. The workstation becomes location-independent compute accessed via Tailscale and Mosh.

Distributed Compute Architecture#

If you compile programs, render video, run VMs, or deploy infrastructure, you do need real compute. The question becomes: where does that compute exist?

The conventional answer is to carry it with you.

But the better answer is to separate the interface from the compute.

How I have done this:#

Workstation: Ryzen 9 5900x, RTX 3080, 32GB RAM, gigabit ethernet, always-on#

Built in 2021, this machine runs in a 4U server chassis: it is silent, cool, and still capable four years later. The chassis permits ATX expansion, multiple GPUs, and drive arrays.

The components will eventually age out, and when they do, they will get replaced individually. The chassis and cooling infrastructure remain.

Laptop: ThinkPad T14s Gen 3, adequate for Emacs and a browser, ~10+ hour battery life#

Bought on sale in 2022, the keyboard remains world-class. Recently installed a new battery - this machine will likely run another 3+ years. When it doesn’t, any used ThinkPad from eBay will do; The hardware is effectively disposable.

Connection: Tailscale + Mosh + tmux#

Tailscale: Zero-trust mesh VPN using WireGuard.

This permits secure connection without exposing SSH to the internet or maintaining traditional VPN infrastructure (OpenVPN configuration, port forwarding, dynamic DNS - all of this is eliminated). Your devices see each other as if they’re on the same LAN, regardless of NAT or firewall topology.

There is no attack surface, no port forwarding configuration, and no IP address memorization.

Mosh: Mobile shell using UDP with predictive local echo.

Mosh survives network transitions (wifi - cellular and back again), laptop sleep/wake, and IP address changes. It compensates for latency by predicting your keystrokes locally. On degraded networks (hotel/cafe wifi or tethering), the difference is substantial - mosh feels responsive where SSH would be laggy and in some cases, unusable.

tmux: Persistent sessions on workstation.

Your compilation, your video render, your long-running process - all continue when you disconnect. Close the laptop, board a plane, reopen elsewhere. `tmux attach` and you’re back in the same session. The compute is stateless from the client’s perspective. I have a simple alias that allows either spawning a tmux session or connecting to the already existing one:

alias logos="mosh joshua@logos -- tmux new-session -A -s main"

The laptop becomes a thin layer into much greater compute: a keyboard, screen, and network interface into that workstation.

NixOS ties this all together#

Both machines run NixOS with configurations declared in version-controlled Nix files. Each host runs nearly identical configurations including:

The experience is truly identical. Open Emacs on either machine - same keybindings, same packages, same org-mode workflow, same project structure. The workstation has better ergonomics. The laptop is portable. But the environment is effectively the same.

Machines as Cattle, Not Pets#

Setup on new hardware takes ~30 minutes:

  1. Install NixOS from USB
  2. Clone nixos-config repository
  3. Run `nixos-rebuild switch`

Everything restores - not from backup archives, but from declared state. Doom Emacs configuration, development tools, system services, user environment. The machine becomes what it should be by reading its configuration, not by restoring snapshots of what it was.

The machines become cattle: replaceable on demand. My Laptop gets stolen? Rebuild in an afternoon with any ThinkPad off Facebook marketplace. My Workstation dies? Deploy the same configuration on replacement hardware - or temporarily on a Hetzner cloud instance while parts ship.

This is infrastructure-as-code at the personal computing level. Most people treat computers like pets - unique, precious, full of undocumented manual configuration accumulated over the years. NixOS lets you treat them like cattle - reproducible, disposable, version-controlled. The machine’s identity is its configuration file, not its physical hardware or installed software state.

Economics#

The naive comparison looks something like: ThinkPad (800)+Workstation(800) + Workstation (2500) - 3300vs.MacBookProM4Max−3300 vs. MacBook Pro M4 Max - 4500

But total cost of ownership over 5 years tells the real story:

Workstation path:#

Laptop-only path:#

The distributed approach costs less than half as much over 5 years.

This also ignores opportunity costs:

Thermal throttling - laptops have this constraint due to chassis size, it’s just physics. You can run sustained workloads on a workstation that would throttle laptops drastically.

Upgrade flexibility: When the workstation’s GPU ages out, drop in a replacement for $500-1000. The chassis, cooling, power supply, and motherboard remain. A laptop GPU is soldered to the motherboard - when it’s obsolete, you replace the entire machine. Sadly Apple makes user replacing a battery a 3 hour ordeal when it should just be a drop-in and many aren’t comfortable with doing a battery swap, so that means a new machine for many people.

Repairability: Your workstation fan died? $15 replacement, 10 minute install.

Your laptop fan died? Requires full motherboard disassembly, often isn’t sold as a separate part, and risks warranty violation.

When the T14s eventually ages out, replacement cost is ~$300-800 for a used ThinkPad on eBay. The workstation continues running. The environment continues working identically.

The laptop is fungible. The workstation is upgradeable. Neither is precious.

Failure Modes and Graceful Degradation#

Inevitably the immidiate objection: “What if I need to work offline?” or “I render video on airplanes”

To which I would simply reply: Our system degrades gracefully, not catastrophically.

Connectivity loss scenarios:#

Home internet down: You can still work locally. Emacs, browser, local git repositories function identically. Continue your development, commit to local branches, then push when connectivity is restored. Heavy compilation and video rendering: wait; or run it locally at reduced efficacy.

On a plane rendering video: The T14s has 32GB RAM and a capable CPU. A 10-minute 4K video render that takes 3 minutes on the workstation takes 12 minutes on the laptop. It is just an annoyance, but you can still get your work done.

For true offline heavy work (multi-hour renders, massive compilation), you have options:

  1. Start the job before leaving (tmux keeps it running)
  2. Accept the performance penalty and run locally
  3. Tether to phone hotspot for remote execution (Mosh handles poor connections well)

You’re not trapped by this solution. The laptop is adequate for the work - the workstation is just optimal.

Hardware failure scenarios:#

Workstation dies: You can deploy our NixOS configuration on replacement hardware. Or spin up an identical environment on Hetzner/Digital Ocean temporarily ($50/month for equivalent specs). The configuration is portable - the hardware isn’t.

Laptop stolen or damaged: Replace with any hardware running NixOS. Used ThinkPad from eBay or FB marketplace. Install NixOS from USB, clone config repo, `nixos-rebuild switch`. Hours to restore, not days.

The real comparison:#

If your MacBook Pro dies, you’re completely blocked until you buy another machine and restore.

Workstation dies: Work locally at reduced performance or spin up cloud instance in 30 minutes.

Laptop dies: Replace with cheap used hardware, restore from config in 30 mins flat.

The truth is that our distributed model has redundancy. The monolithic laptop model has a single point of failure, hence why I stopped caring about it.

Technological Sovereignty Through Distributed Compute#

This post isn’t really about laptops not mattering. It’s about computing independence:

This is the same architecture behind “The Cloud (TM)” - separation of stateless frontends from scalable backends, declarative configuration management, location-independent compute.

But you’ve kept it under our control.

No AWS bills or surprises. No vendor deciding which ports you can use (I had to contact Hetzner to allow email ports!). No terms of service changes. No cloud provider reading your data for AI training.

You’re running your own personal cloud with zero lock-in. The laptop is just an SSH client. It doesn’t matter because you’ve made it not matter - you’ve moved everything that matters into declared, reproducible, distributed infrastructure.

We have built something here that provides redundancy while giving us sovereignty, and at the end of the day, that’s what it’s all about.

As always, God bless, and until next time.

If you enjoyed this post, consider Supporting my work, Checking out my book, Working with me, or sending me an Email to tell me what you think.