MW↗MOVE WEIGHTFIELD GUIDE / 01Start here ↘

SELF-HOSTING / PRACTICAL FIELD NOTES

Build services you can bring back.

A calm route from one small server to a dependable home stack. Decide what to isolate, what to expose, and how you will restore it before adding the next app.

Informed by a real multi-node Proxmox lab. Private names, addresses, and findings are omitted.

A useful mental model
A self-hosting stack from internet to recoveryTraffic passes through a gateway and reverse proxy to virtual machines or containers; monitoring and backup surround the stack.OUTSIDEInternetBOUNDARYGateway + rulesENTRYProxy + identityWORKLOADLXC / VMOBSERVEHealth, alerts, capacityRECOVERBackup + restoreKeep the management plane private.
● Request path● Operations around it
01 / Choose a path02 / Lay out the system03 / Operate it safelyREVIEWED 08 NOV 2026
A / THE PRINCIPLE

Start with the thing you need to trust.

Self-hosting is a chain: power, host, network, storage, identity, and the app. A tidy dashboard cannot compensate for a missing restore path. Build one reliable service, document it, then reuse that pattern.

Make recovery
the default.
B / PATHFINDER

Choose by consequence.

Answer top to bottom. Follow the branch that matches the failure you can live with.

01
ACCESS

Who needs to reach it?

Only you or household

Use a private VPN or tailnet. Give it the few routes it needs; keep admin pages off the public internet.

WIREGUARD / TAILSCALE
then decide where trust belongs ↓
02
ISOLATION

Does it need a separate kernel or special access?

Small, trusted Linux service

An unprivileged LXC is light to manage. The host kernel is shared; grant only required mounts and features.

LXC / SYSTEMD
before moving real data ↓
03
DATA

What would hurt to recreate?

Replaceable cache or downloads

Local storage and snapshots may be enough. Label it disposable and exclude it intentionally.

REBUILDABLE
then set the availability target ↓
04
AVAILABILITY

How long can it be down?

Hours are acceptable

One host, good backups, and a written rebuild order can be a sensible design.

KEEP IT SIMPLE
Good default: keep management VPN-only, expose one app route, store persistent data separately, and rehearse a restore before scaling.
C / A WORKING BLUEPRINT

Keep the layers visible.

This reference is drawn from an anonymized, real multi-node Proxmox setup: role-based LXCs, Traefik ingress, Authentik identity, AdGuard Home with Unbound, local storage, and an NFS backup target. Exact inventory stays private.

01 / EDGERouter / firewall

Owns internet routing, DHCP, and the first allow/deny boundary. Keep its admin interface trusted.

ONE CLEAR OWNER
02 / NETWORKTrust zones

Separate management, servers, trusted clients, IoT, and guests when gateway, switch, and APs support it.

DEFAULT DENY
03 / COMPUTEProxmox VE

A cluster can centralize management. It does not create shared storage, backup copies, or automatic recovery by itself.

PATCHED HOSTS
04 / INGRESSProxy + identity

Traefik routes app traffic; Authentik provides shared sign-in. Keep hypervisor, DNS, and backup consoles private.

TLS + MFA
05 / WORKLOADSLXC / VM / Compose

Give each service an owner and data path. Use VMs when isolation, kernel features, or device passthrough justify it.

LEAST PRIVILEGE
06 / DATAVolumes + backups

Separate app state from replaceable files. Guest backups may skip bind mounts or volumes marked to exclude; read job output.

RESTORE TESTED
07 / OPERATIONSSignals + runbook

Alert on failed jobs, thin-pool headroom, disk health, and certificates. Write the order to rebuild DNS, identity, ingress, then apps.

SOMEONE GETS PAGED
◎

What this guide leaves out: exact hostnames, IPs, guest IDs, URLs, ports, and security findings. This is a reusable architecture guide, not a live service map.

D / REAL WORKFLOWS

From a box in the rack to something you use.

These playbooks follow this lab’s shape: Proxmox and an AI node, Move Weight Manager, creative AI tools, Cloudflare DNS, Traefik, and a Hestia hosted site. Private names and addresses are removed. Each guide includes alternatives for different budgets and skills.

ONE LAB / THREE SERVICE PATHSFollow a line, then open its guide below
Choose the service path
PUBLIC WEBSITE
Your domain → Cloudflare → Traefik → HestiaPublish one named web route
LOCAL AI + CREATION
Browser / VPN → Forgeverse Bridge or direct access → AI node (ComfyUI / Ollama)Forgeverse catalog + Mesh2Motion are separate workflows
HOME MEDIA + GAMES
LAN / VPN → media or game host → your deviceDirect play when possible; encode only when needed

Cloudflare serves public DNS. Traefik routes requests. The domain remains yours. The proxy does not replace access control or backups.

01 / COMPUTEBack to map ↑

Run a Proxmox lab you can understand

Treat each node as hardware first and a cluster member second. Assign services by their needs, give every guest a purpose, and record where its data lives.

Build and operate

  1. Install Proxmox VE on each suitable host; set stable management addresses, time sync, updates, and alert delivery.
  2. Use the cluster for a shared view and migrations where configured. Check quorum, network paths, and storage before relying on HA.
  3. Use an unprivileged LXC for a small, trusted Linux service. Choose a VM for a separate kernel, broad Docker access, unusual drivers, or GPU passthrough.
  4. Name guests by role; record CPU/RAM/disk limits and persistent data paths. Avoid host-level privileges for web workloads.
  5. Back up a new guest before adding irreplaceable state. Confirm the job includes its disks and separately mounted data.

Keep a host ledger

  • Node model, CPU, clock, physical/logical cores, installed RAM
  • Each physical drive: model, media type, capacity, health, and role
  • Guest purpose, backup job, data paths, and restore order
  • Hardware passthrough needs and recovery access if cluster services fail

Alternatives: Incus for containers and VMs; Debian with libvirt for one flexible host; TrueNAS or Unraid for storage-first setups. Choose what you will patch and restore.

FIELD NOTE / MWMMWM source ↗

Make the inventory match the physical machines

A Proxmox node may also run an MWM agent. Those are two observations of one computer, not two computers. Link duplicate sources by stable identity and hardware details before totaling resources.

Use MWM as the fleet view

  1. Connect each host or Proxmox source with least-privilege access and a clear source label.
  2. Compare hostname, system product, CPU, memory, and disks. Link the agent and hypervisor record when they describe one chassis.
  3. Count physical RAM, cores, GPUs, and drives once per host. Show missing telemetry as unavailable; do not confuse guest allocations with installed memory.
  4. Separate SSD/NVMe and HDD by physical model/type when telemetry supports it. Keep virtual disks and storage-pool capacity in their own totals.
  5. Use health checks to find attention items, then open the originating system. MWM is inventory and operations visibility, not a backup.

What the overview should answer

  • How many unique physical hosts are online?
  • Which CPUs, speeds, cores, and installed RAM?
  • How much GPU memory is actually reported?
  • How many SSD/NVMe and HDD drives, and what capacities?
  • Which values are host totals, guest allocations, pool totals, or unavailable?

Keep credentials and API keys in a secret store. Never put tokens in screenshots, docs, shell history, or a public page.

Give AI jobs a home on your network

Decide whether you need a local inference endpoint, a creative workstation, or a GPU shared by both. A separate AI host can avoid coupling model drivers to the hypervisor.

Set up the route

  1. Choose bare metal for a dedicated workstation or a VM when isolation and supported GPU passthrough justify it. Verify IOMMU and driver support before changing a working host.
  2. Install and pin the vendor driver, runtime, and model server from official instructions. Record the working versions.
  3. Bind the inference API to localhost or a trusted interface. Use VPN/firewall allowlists for remote clients; never publish an unauthenticated model API.
  4. Store model weights on a deliberate data volume. Separate replaceable caches from prompts, outputs, and projects worth backing up.
  5. Measure VRAM use, speed, and concurrent workload with your models. Hardware labels alone do not predict performance.

Choose a model runner

Ollama is a straightforward local runner. llama.cpp supports quantized models and varied hardware. vLLM may suit serving workloads; LM Studio offers a desktop workflow. Hosted APIs reduce local maintenance but send requests off-site and may cost per use.

Hybrid routing is practical: keep sensitive work local and use a hosted service for models your hardware cannot run well.

03 / IMAGE + VIDEO WORKFLOWSComfyUI documentation ↗

Keep ComfyUI workflows portable

ComfyUI is a node-based interface for generative workflows. Separate the application, models, custom nodes, workflow files, and output library so upgrades do not erase work.

Workflow

  1. Install from the official instructions for your OS and GPU. Confirm the supported Python/runtime and driver combination for that release.
  2. Set explicit locations for checkpoints, LoRAs, VAE files, custom nodes, input, and output. Keep large model files on a volume with headroom.
  3. Start from a known workflow and small image. Save workflow JSON with model names, hashes, node versions, and dependencies.
  4. Back up workflows, custom-node lists, configuration, and valuable outputs separately from replaceable model caches.
  5. Before upgrading, copy the environment and try one workflow. Restore the known-good version if a dependency breaks.

Make it reachable safely

Use ComfyUI on the workstation, LAN, or VPN. Add authentication if trusted people need access. Keep the raw UI and API off public DNS; a reverse proxy alone is not authentication.

Alternatives: Forgeverse can provide a creative catalog and AI connections; desktop tools suit a single workstation; hosted generation fits occasional jobs or oversized models.

04 / CREATIVE WORKBENCHForgeverse ↗

Use Forgeverse as the creative front door

Forgeverse brings creative apps and AI providers into one workspace. Catalog and integrations evolve, so check the current site for available tools and providers instead of assuming every item runs locally.

A repeatable project path

  1. Choose a catalog app for the task: image, vector, layout, video, audio, 3D, character, documents, or CAD tools as currently available.
  2. Start a named project and import sources. Keep originals in a backed-up project folder and export formats the receiving app can reopen.
  3. For AI work, select an approved provider. Connect supported local services such as ComfyUI or Ollama through Forgeverse Bridge where available.
  4. Keep the Bridge on the workstation or trusted LAN. Check the provider, endpoint, and permissions; never expose a local service just to make a browser integration work.
  5. Save source, settings, generated assets, and export together. Reopen the export in its target app before calling it finished.

Local and hosted paths

Local providers offer control but use your hardware, power, storage, and maintenance time. Hosted providers ease setup and may offer larger models; review data handling and pricing.

Forgeverse includes a broad creative app catalog, AI-provider connections, local runtimes, MCP integrations, and media-service connections; the exact catalog changes over time. It currently advertises more than 40 creative apps and 60+ AI providers across photo, vector, layout, film, audio, 3D, characters, documents, and CAD.

Local Bridge calls go from the browser to your local service without passing through Forgeverse. The Bridge is a small Python script; keep it and the connected AI endpoint on your workstation, LAN, or VPN. It is not a public reverse proxy. Signed-in provider keys are stored by Forgeverse using account-scoped encryption; review current connection and privacy documentation before saving a key.

Use Forgeverse’s current docs for account, Bridge, provider, and project behavior. Never put account keys in a public guide or shared workflow.

FORGEWEAVER / SITE EDITING WORKSPACECode → Design → Split → Preview

Code

Edit project files in a multi-tab code editor; search, compare diffs, and apply reviewed changes.

Design

Visually edit HTML with blocks and a style panel. CSS changes use an override file so original stylesheets remain intact. Framework components stay code-edited.

Preview

Inspect responsive sizes, capture a preview, and refresh after saved changes. The current preview serves static files; it does not run npm/Vite builds or framework HMR.

Git + AI

Review status, file diffs, history, branches, and commits. Ask the connected AI about selected project context, then inspect the proposed diff before applying it.

Practical flow: make a project copy → edit → preview common screen sizes → review the diff → commit → deploy through your usual host. Treat the preview as a design check, not proof that a production build succeeds.

05 / 3D MOTIONMesh2Motion ↗

Turn a motion idea into a reusable 3D asset

Mesh2Motion supports browser-based motion generation and downloadable assets. Input formats, exports, and offline builds can change; check its current release documentation.

Project sequence

  1. Prepare a supported character mesh and preserve an untouched source copy. Confirm scale, orientation, skeleton needs, and file format.
  2. Describe the motion clearly. Generate a short preview before a long sequence.
  3. Review foot contact, balance, intersections, and transitions. Iterate, then save the chosen generation with the source model.
  4. Export to a format your next tool accepts; validate it in Blender or the target game/animation app. Preserve the original and note retargeting steps.
  5. Back up source models, prompts/settings, and final exports. Treat caches as disposable only when sources are safe.

Where it fits

Use it for rapid motion exploration, then clean and retarget in Blender or a dedicated animation tool. For mature rigging pipelines, compare established DCC tools before changing production formats.

Check current license, data handling, supported formats, and local versus hosted processing before using client or commercial assets.

06 / YOUR DOMAIN + WEB HOSTBack to map ↑

Own the domain and route a site through your stack

The registrar, Cloudflare DNS zone, Traefik edge, and Hestia web account have separate jobs. Record who owns each one and keep management interfaces private.

Publish one site

  1. Register a domain with a registrar you control. Turn on renewal alerts, MFA, registrar lock, and offline recovery codes.
  2. Add it to Cloudflare and verify authoritative nameservers. Create only DNS records needed for the hostname.
  3. If Traefik uses a DNS challenge, create a scoped token for the specific zone and required DNS permissions. Store it in Traefik’s secret mechanism and limit readers.
  4. Configure a Traefik router for the exact hostname and backend. Add TLS and only necessary middleware. Keep the Traefik dashboard private.
  5. In Hestia, create the web domain, set the document root, and configure intended TLS/proxy settings. Deploy files with correct owner and permissions.
  6. Check DNS, certificate, redirects, and public response from outside your network. Ensure the origin firewall allows only the intended path.
  7. Back up DNS records, Traefik configuration, Hestia files, and databases. Rotate a token if it enters logs or public files.

Choose how traffic enters

Port forward: send inbound web traffic to Traefik and keep other ports closed. Cloudflare Tunnel: an outbound connector avoids inbound origin ports but depends on Cloudflare. VPS relay: useful when an ISP blocks inbound traffic, with another server to maintain.

DNS/proxy is not identity. Add app authentication where needed. Keep Proxmox, router, DNS, backup, and raw AI consoles off public routes. Use Hestia’s documented panel workflow instead of editing generated config it may overwrite.

# Pattern only; replace hostname and backend
http:
  routers:
    example-site:
      rule: "Host(`example.com`)"
      entryPoints: [websecure]
      service: example-site
      tls:
        certResolver: cloudflare
  services:
    example-site:
      loadBalancer:
        servers:
          - url: "http://SITE_BACKEND:PORT"

Stream your own media reliably

A media server indexes and plays your library. Keep media files, metadata/database, and app configuration in known locations so reinstalling does not mean rebuilding everything.

Build the path

  1. Choose a server: Jellyfin is self-hosted and open source; Plex emphasizes a polished client ecosystem; Emby is another option. Check client support on your devices.
  2. Mount libraries read-only where practical. Use consistent names; keep import staging separate from the final library.
  3. Try direct play first. If transcoding is needed, verify codecs, GPU/CPU acceleration, subtitles, and network bandwidth.
  4. Use a reverse proxy only for remote web access; configure its documented headers and WebSockets. Keep administration private and secure accounts.
  5. Back up settings and metadata. Decide whether large replaceable media needs another copy; protect anything you cannot reacquire.

Make playback smooth

Prefer wired networking for the server and access point. Test real bitrate and client codec support before buying hardware. Transcoding needs decode/encode capability and sustained headroom.

Remote playback also depends on upload speed and the client network. Use media you own or are licensed to access.

08 / GAME STREAMINGSunshine setup ↗

Keep game streaming on the fast path

The host captures a game, encodes frames, and sends them to a client. A wired local network and working encoder usually matter more than a public web proxy.

Pair and tune

  1. Install Sunshine on the gaming host and Moonlight on clients using official instructions. Check GPU encoding and audio locally.
  2. Pair clients on the trusted home network. Start with modest resolution, frame rate, and bitrate; increase one at a time.
  3. Use Ethernet for the host where possible. Measure latency, packet loss, and encode time separately from internet speed.
  4. For travel, prefer a VPN or supported relay. If direct access is necessary, expose only documented streaming ports and restrict firewall scope; keep the admin UI private.
  5. Record controller mappings, game launch behavior, wake-from-sleep, and recovery after GPU driver updates.

Alternatives

Steam Remote Play suits Steam libraries. Parsec can fit remote desktop and collaboration. Console-native remote play is simplest for console games. Compare latency, clients, privacy, and account needs.

Cloud gaming removes the home host but depends on a provider catalog, subscription, and internet route. Traefik is not the game-stream transport.

Make the whole stack recoverable

A guest snapshot is useful for rollback. A backup is an independent copy that can survive failure of its source. Keep app state and reconnection steps.

Back up by layer

  1. Proxmox: back up guest disks and config to another system or PBS; verify job output and retention.
  2. Web edge: save Traefik config and secret references. Export Cloudflare DNS records; document registrar recovery without credentials in the export.
  3. Hestia: include site files, databases, mail if used, and panel data. Store a copy off the host.
  4. Creative work: protect ComfyUI workflows, custom-node manifests, prompts/settings, project sources, and valuable outputs. Model caches can be rebuilt if their source is recorded.
  5. Media and games: back up metadata, settings, saves, and game-library configuration. Decide whether large media originals need a second copy.
  6. Secrets: store encrypted recovery data in a controlled vault. Verify the vault still works when primary identity services are down.
  7. Restore a guest and representative file to a temporary target. Record time, missing dependencies, and who can perform it.

Write a recovery order

  1. Power, network, trusted management access
  2. DNS and time sync
  3. Proxmox storage and backup access
  4. Identity and edge proxy
  5. Web hosting and databases
  6. AI, media, and other apps

Keep an offline copy of the order, network layout, and restore contacts. Do not put live passwords or tokens in it.

E / PICK YOUR TOOLS

Use the stack you can explain.

“Seen here” anchors this guide in a working setup. Alternatives fit different budgets, skills, and failure targets.

LayerSeen hereAlternativesChoose when
HostProxmox VE
Multi-node LXC and VM mgmt
Incus; TrueNAS SCALE; Unraid; Debian + libvirtChoose the UI and recovery model you will maintain. One host is a fine start.
WorkloadRole-based LXCs
Some nested app stacks
Compose in a VM; Podman; systemd; full VMsLXC for trusted Linux services and density; VM for stronger kernel boundary or hardware.
IngressTraefikCaddy; Nginx Proxy Manager; Cloudflare Tunnel; VPS relayCaddy favors compact config and automatic HTTPS. A tunnel avoids inbound origin ports but adds a provider dependency.
IdentityAuthentikAuthelia; existing identity provider; app-native MFAUse single sign-on where supported. Keep a tested local recovery account.
DNSAdGuard Home + UnboundPi-hole + Unbound; Technitium; router DNSPut two resolvers on different failure domains. Same host or circuit is partial redundancy.
StorageLVM-thin, mounted data, NFSZFS mirrors; NAS shares; object storage for off-siteSnapshots help roll back; they do not replace an independent backup.
BackupScheduled vzdump to NFSProxmox Backup Server; restic or Borg off-hostKeep one copy outside the source host. Encrypt off-site data and test restores.
Local AIDedicated AI host + local tools
Private LAN/VPN
Ollama; llama.cpp; LM Studio; vLLM; hosted APIsLocal control costs hardware and maintenance; hosted models trade data control for less local setup.
Creative AIComfyUI + Forgeverse
Workflows and creative front door
Blender; Krita; desktop AI apps; hosted suitesUse formats your next editor can reopen. Keep project sources beside exports.
MotionMesh2Motion
Motion exploration
Blender; Mixamo; Cascadeur; other DCC toolsCheck formats and licensing; validate exports in the consuming tool.
MediaSelf-hosted media server
LAN-first playback
Jellyfin; Plex; Emby; NAS appsMatch clients and codecs; direct play is simpler. Back up metadata and config.
Game streamingHome gaming host
Private network path
Sunshine + Moonlight; Steam Remote Play; Parsec; console remote playTune local latency and encoder first. Prefer VPN for remote access.
Public websiteCloudflare + Traefik + Hestia
Domain you control
Caddy; Nginx Proxy Manager; tunnel; VPS; static hostingScope DNS tokens, publish app routes only, and keep an off-host copy.
MonitoringProxmox task viewsUptime Kuma; Prometheus + Grafana; hosted alertsStart with failed backup, low space, unreachable DNS, and expiring certificate.
F / BEFORE THE FIRST APP

A short safe-start checklist.

Do these in order. Save each answer somewhere outside the server being configured.

01

Map the physical layer

Label hosts, disks, switch ports, gateway, UPS, and recovery access. Record management addressing.

02

Reserve names and addresses

Use DHCP reservations for infrastructure and local home.arpa names. Document the resolver path.

03

Back up before adding state

Include guest disks, databases, bind mounts, media, secrets, and config as needed. Verify a restore.

04

Separate trust zones

Keep admin devices and management UIs private. Isolate IoT and guests with narrow rules where possible.

05

Publish one route

Use one proxy or tunnel. Add TLS, MFA, and an update owner; never publish the hypervisor console.

06

Write the rollback

Record known-good config, restore steps, and local host access if DNS, proxy, or identity is down.

G / KEEP IT BORING

The monthly rhythm.

Operations are part of design. A system is not recoverable until someone follows its recovery steps.

WEEKLY

Read the failure queue

Check jobs, disk alerts, failed logins, certificates, and service health. Confirm alerts reach a real inbox.

MONTHLY

Restore something

Restore a guest or file to a temporary target. Check data and startup; record time and missing steps.

MAINTENANCE WINDOW

Update in layers

Read release notes, check headroom, verify backups, update one layer, and keep rollback before the next.

WHEN THE STACK CHANGES

Update the map

Record what moved, the data it owns, what can reach it, how it is backed up, and who gets alerts.

THE GOOD QUESTION

Can you bring it back
without guessing?

Start at the top ↑
H / PRIMARY REFERENCES

Read the docs that own the behavior.

Versions and defaults change. Check upstream documentation before copying configuration into a live system.