VPS Specs Part 3: Creative and Unique

🏠 Homer Dashboard

RAM: ~2 MB | Tech: HTML/JS

2 MB RAMHTML/JSDockerUltra-Light

Dead-simple static homepage for your server. YAML config, no database. Shows all services as beautiful tiles with icons and status.

Architecture

User --> Homer (:8080) --> YAML Config
              |
         Service Tiles
         Icons
         Status Checks
         Custom CSS

Docker Compose

services:
  homer:
    image: b4bz/homer:latest
    container_name: homer
    volumes:
      - ./config:/www/assets
    ports:
      - "8080:8080"
    restart: unless-stopped

Caddy Reverse Proxy

# Main dashboard - can be root domain
example.com {
  reverse_proxy homer:8080
}

Security Hardening

Restrict to VPN access
Use Caddy for HTTPS
Custom CSS for branding
No sensitive info in tiles

Backup Strategy

Backup config/ directory (YAML + icons)

Health Check

curl -s http://localhost:8080/ | grep -q Homer

📊 Homepage Dashboard

RAM: ~30 MB | Tech: Node.js

30 MB RAMNode.jsDocker

Modern fully-featured app dashboard. Auto-discovers Docker containers, integrates 100+ services, real-time stats, weather, calendar widgets.

Architecture

User --> Homepage (:3000) --> Docker Socket
              |
         Auto-Discovery
         Widgets
         100+ Integrations

Docker Compose

services:
  homepage:
    image: ghcr.io/gethomepage/homepage:latest
    container_name: homepage
    volumes:
      - ./config:/app/config
      - /var/run/docker.sock:/var/run/docker.sock:ro
    ports:
      - "3000:3000"
    restart: unless-stopped

Caddy Reverse Proxy

dashboard.example.com {
  reverse_proxy homepage:3000
}

Security Hardening

Restrict Docker socket access
Use environment variables for API keys
Restrict to VPN
Regular config backups

Backup Strategy

Backup config/ directory (YAML files)

Health Check

curl -s http://localhost:3000/ | grep -q Homepage

💾 Syncthing

RAM: ~30 MB | Tech: Go

30 MB RAMGoDocker

Continuous file synchronization between devices. No cloud needed - VPS acts as always-on relay node. Sync folders with encryption.

Architecture

Laptop <-> Syncthing VPS (:8384) <-> Phone
              |
         Always-on
         Relay Node
         Encrypted
         P2P Sync

Docker Compose

services:
  syncthing:
    image: syncthing/syncthing:latest
    container_name: syncthing
    hostname: vps-sync
    environment:
      PUID: 1000
      PGID: 1000
    volumes:
      - ./syncthing-data:/var/syncthing
      - ./shared:/var/syncthing/shared
    ports:
      - "8384:8384"
      - "22000:22000/tcp"
      - "22000:22000/udp"
      - "21027:21027/udp"
    restart: unless-stopped

Caddy Reverse Proxy

sync.example.com {
  reverse_proxy syncthing:8384
}

Security Hardening

Set GUI password
Use API key for automation
Enable TLS for relay
Restrict shared folders

Backup Strategy

Backup syncthing-data/ for config. Shared files are synced across devices.

Health Check

curl -s http://localhost:8384/rest/system/status

📚 KoReader Sync Server

RAM: ~20 MB | Tech: Go

20 MB RAMGoDockerNiche

Sync reading progress, highlights, and notes for e-books across devices. Paired with Calibre-web for personal e-book library.

Architecture

KoReader App --> Sync Server (:8090) --> KoReader App
                    |
               Reading Progress
               Highlights
               Notes

Docker Compose

services:
  koreader-sync:
    image: ghcr.io/koreader/koreader-sync-server:latest
    container_name: koreader-sync
    volumes:
      - ./koreader-data:/data
    ports:
      - "8090:8090"
    restart: unless-stopped

Caddy Reverse Proxy

koreader.example.com {
  reverse_proxy koreader-sync:8090
}

Security Hardening

Enable authentication
Use HTTPS only
Regular data backups
Limit to known devices

Backup Strategy

Backup koreader-data/ directory

Health Check

curl -s http://localhost:8090/

🎵 Navidrome

RAM: ~50 MB | Tech: Go

50 MB RAMGoDocker

Self-hosted music streaming server. Subsonic-compatible API, works with 50+ mobile apps. Stream your music library to any device.

Architecture

User --> Navidrome (:4533) --> Music Files
              |
         Subsonic API
         50+ Mobile Apps
         Transcoding
         Playlists

Docker Compose

services:
  navidrome:
    image: deluan/navidrome:latest
    container_name: navidrome
    environment:
      ND_SCANSCHEDULE: 1h
      ND_LOGLEVEL: info
      ND_BASEURL: ""
    volumes:
      - ./navidrome-data:/data
      - /path/to/music:/music:ro
    ports:
      - "4533:4533"
    restart: unless-stopped

Caddy Reverse Proxy

music.example.com {
  reverse_proxy navidrome:4533
}

Security Hardening

Enable user authentication
Disable public sharing
Use HTTPS only
Rate limit API access

Backup Strategy

Backup navidrome-data/ (DB, playlists). Music files backed up separately.

Health Check

curl -s http://localhost:4533/ping

📷 PhotoPrism

RAM: ~300 MB | Tech: Go

300 MB RAMGoDockerHeavy

AI-powered photo management. Face recognition, object detection, geolocation, search. Beautiful web UI. Needs swap on 1GB VPS.

Architecture

User --> PhotoPrism (:2342) --> Photos DB
              |
         AI Analysis
         Face Recognition
         Object Detection
         Geo Location

Docker Compose

services:
  photoprism:
    image: photoprism/photoprism:latest
    container_name: photoprism
    environment:
      PHOTOPRISM_ADMIN_PASSWORD: changeme
      PHOTOPRISM_HTTP_PORT: 2342
      PHOTOPRISM_ORIGINALS_PATH: /photoprism/originals
      PHOTOPRISM_STORAGE_PATH: /photoprism/storage
    volumes:
      - ./photoprism-storage:/photoprism/storage
      - /path/to/photos:/photoprism/originals
    ports:
      - "2342:2342"
    restart: unless-stopped

Caddy Reverse Proxy

photos.example.com {
  reverse_proxy photoprism:2342
}

Security Hardening

Strong admin password
Disable public sharing
Enable HTTPS
Limit concurrent indexing

Backup Strategy

Backup photoprism-storage/ (DB, cache, settings). Photos in originals/.

Health Check

curl -s http://localhost:2342/api/v1/status

📺 Jellyfin

RAM: ~200 MB | Tech: C#

200 MB RAMC#Docker

Free media server for movies, TV, music, books. Streams to any device. Without transcoding, runs fine on 1GB VPS.

Architecture

User --> Jellyfin (:8096) --> Media Files
              |
         Direct Play
         (No Transcode)
         Libraries
         Metadata

Docker Compose

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    volumes:
      - ./jellyfin-config:/config
      - ./jellyfin-cache:/cache
      - /path/to/media:/media:ro
    ports:
      - "8096:8096"
    restart: unless-stopped

Caddy Reverse Proxy

media.example.com {
  reverse_proxy jellyfin:8096
}

Security Hardening

Disable transcoding (1GB VPS)
Enable user accounts
Restrict remote access
Use HTTPS

Backup Strategy

Backup jellyfin-config/ (settings, DB). Media files separate.

Health Check

curl -s http://localhost:8096/health

📻 Readeck

RAM: ~15 MB | Tech: Go

15 MB RAMGoDocker

Read-later plus RSS reader. Single Go binary. Tags, collections, full-text search. Clean, fast, no bloat.

Architecture

User --> Readeck (:8080) --> SQLite DB
              |
         Content Extraction
         RSS Feeds
         Tags
         Collections

Docker Compose

services:
  readeck:
    image: codeberg.org/readeck/readeck:latest
    container_name: readeck
    environment:
      READECK_SECRET_KEY: your-secret-key
    volumes:
      - ./readeck-data:/readeck/data
    ports:
      - "8080:8080"
    restart: unless-stopped

Caddy Reverse Proxy

readeck.example.com {
  reverse_proxy readeck:8080
}

Security Hardening

Enable user authentication
Set strong secret key
Rate limit saves
Regular data backups

Backup Strategy

Backup readeck-data/ directory (SQLite DB + extracted content)

Health Check

curl -s http://localhost:8080/api/bookmarks

💬 Conduit (Matrix Server)

RAM: ~80 MB | Tech: Rust

80 MB RAMRustDocker

Lightweight Matrix chat server in Rust. Federated, E2E encrypted, bridges to IRC/Discord/Telegram. Your own Slack/WhatsApp.

Architecture

Users --> Conduit (:8448) --> Matrix Network
              |
         E2E Encryption
         Federation
         Bridges
         Rooms

Docker Compose

services:
  conduit:
    image: matrixconduit/matrix-conduit:latest
    container_name: conduit
    environment:
      CONDUIT_SERVER_NAME: matrix.example.com
      CONDUIT_DATABASE_PATH: /var/lib/conduit/conduit.db
      CONDUIT_PORT: 8448
    volumes:
      - ./conduit-data:/var/lib/conduit
    ports:
      - "8448:8448"
    restart: unless-stopped

Caddy Reverse Proxy

matrix.example.com {
  reverse_proxy conduit:8448
}

Security Hardening

Use strong server name (FQDN)
Set up bridges carefully
Enable federation rules
Regular DB backups

Backup Strategy

Backup conduit-data/ directory (SQLite DB)

Health Check

curl -s http://localhost:8448/_matrix/key/v2/server

🔊 Mumble

RAM: ~10 MB | Tech: C++

10 MB RAMC++Easy

Low-latency, high-quality voice chat server. Crystal clear audio, positional audio for games, certificate-based auth.

Architecture

Users --> Mumble Server (:64738) --> Channels
              |
         Low Latency
         Certificate Auth
         Positional Audio

Docker Compose

services:
  mumble-server:
    image: mumblevoip/mumble-server:latest
    container_name: mumble
    environment:
      MUMBLE_CONFIG_password: changeme
      MUMBLE_CONFIG_welcometext: Welcome!
    volumes:
      - ./mumble-data:/data
    ports:
      - "64738:6478/tcp"
      - "64738:6478/udp"
    restart: unless-stopped

Caddy Reverse Proxy

# Not proxied - Mumble uses custom TCP/UDP protocol

Security Hardening

Set strong server password
Use certificate auth
Set up channel permissions
Enable SuperUser password

Backup Strategy

Backup mumble-data/ directory (config + DB)

Health Check

Check with Mumble client connection

🧩 Wiki.js

RAM: ~100 MB | Tech: Node.js

100 MB RAMNode.jsDocker

Beautiful modern wiki with Markdown, Git storage, and full-text search. Personal notes, docs, knowledge base, or team wiki.

Architecture

User --> Wiki.js (:3000) --> PostgreSQL
              |
         Markdown Editor
         Git Sync
         Full-text Search
         Multi-user

Docker Compose

services:
  wikijs:
    image: ghcr.io/requarks/wiki:latest
    container_name: wiki
    environment:
      DB_TYPE: postgres
      DB_HOST: wiki-db
      DB_PORT: 5432
      DB_USER: wikijs
      DB_PASS: changeme
      DB_NAME: wikijs
    volumes:
      - ./wiki-data:/wiki/data
    ports:
      - "3000:3000"
    depends_on: [wiki-db]
    restart: unless-stopped
  wiki-db:
    image: postgres:15-alpine
    container_name: wiki-db
    environment:
      POSTGRES_DB: wikijs
      POSTGRES_USER: wikijs
      POSTGRES_PASSWORD: changeme
    volumes:
      - ./wiki-db:/var/lib/postgresql/data
    restart: unless-stopped

Caddy Reverse Proxy

wiki.example.com {
  reverse_proxy wiki:3000
}

Security Hardening

Enable authentication (OIDC/LDAP)
Set up Git sync for backup
Restrict editing permissions
Regular DB dumps

Backup Strategy

pg_dump wikijs > wiki_backup.sql

Health Check

curl -s http://localhost:3000/graphql -X POST -H 'Content-Type: application/json' -d '{"query":"{pages{total}}"}'

📝 DokuWiki

RAM: ~15 MB | Tech: PHP

15 MB RAMPHPNo Database

Flat-file wiki - no database needed! PHP-based, ~15 MB RAM. Perfect for personal notes, documentation. Battle-tested since 2004.

Architecture

User --> DokuWiki (:80) --> File System
              |
         Plain Text Files
         Markup Syntax
         Plugins
         ACL

Docker Compose

services:
  dokuwiki:
    image: linuxserver/dokuwiki:latest
    container_name: dokuwiki
    environment:
      PUID: 1000
      PGID: 1000
    volumes:
      - ./dokuwiki-data:/config
    ports:
      - "8080:80"
    restart: unless-stopped

Caddy Reverse Proxy

dokuwiki.example.com {
  reverse_proxy dokuwiki:80
}

Security Hardening

Set ACL permissions
Enable HTTPS
Disable public registration
Use strong admin password

Backup Strategy

Backup dokuwiki-data/ directory (flat files, super simple)

Health Check

curl -s http://localhost:8080/ | grep -q DokuWiki

🎮 Minecraft Server

RAM: ~700 MB | Tech: Java

700 MB RAMJavaHeavyFun

Paper server for friends! With 1GB, limit to 4-5 players and use Aikar flags. Add Geyser for Bedrock cross-play.

Architecture

Players --> Paper Server (:25565) --> World Data
              |
         Optimized
         Plugins
         Geyser (Bedrock)
         Aikar Flags

Docker Compose

services:
  minecraft:
    image: itzg/minecraft-server:latest
    container_name: minecraft
    environment:
      EULA: "TRUE"
      TYPE: PAPER
      MEMORY: 768M
      ENABLE_RCON: "true"
      RCON_PASSWORD: changeme
      DIFFICULTY: normal
      MAX_PLAYERS: 5
      MOTD: My Server
    volumes:
      - ./minecraft-data:/data
    ports:
      - "25565:25565"
      - "19132:19132/udp"
    restart: unless-stopped

Caddy Reverse Proxy

# Not proxied - Minecraft uses custom protocol
# RCON can be proxied if needed

Security Hardening

Set operator whitelist
Enable whitelist mode
Use RCON password
Regular world backups
Limit player count

Backup Strategy

Backup minecraft-data/ directory (world + config). Use tar or rsync.

Health Check

rcon-cli list

🤖 Telegram/Matrix Bots

RAM: ~20 MB/bot | Tech: Python/JS

20 MB/botPython/JSEasy

Host custom bots for Telegram, Discord, or Matrix. RSS feed bots, reminder bots, chatbots, translation bots.

Architecture

Telegram/Discord --> Bot Process (:port) --> Actions
                        |
                   Message Handler
                   Webhooks
                   Scheduled Tasks

Docker Compose

services:
  telegram-bot:
    image: python:3.11-slim
    container_name: telegram-bot
    working_dir: /app
    volumes:
      - ./bot-code:/app
    environment:
      BOT_TOKEN: your-telegram-bot-token
    command: python bot.py
    restart: unless-stopped
  # Example: RSS-to-Telegram bot
  rss-bot:
    image: python:3.11-slim
    container_name: rss-bot
    working_dir: /app
    volumes:
      - ./rss-bot:/app
    environment:
      TELEGRAM_TOKEN: your-token
      CHAT_ID: your-chat-id
    command: python rss_to_telegram.py
    restart: unless-stopped

Caddy Reverse Proxy

# Bots connect outbound to Telegram/Discord APIs
# No inbound proxy needed

Security Hardening

Use environment variables for tokens
Rate limit bot responses
Log errors to file
Use webhooks for efficiency

Backup Strategy

Backup bot-code/ directory. Tokens stored in environment/secrets.

Health Check

Check bot logs: docker logs telegram-bot

💡 Whoogle

RAM: ~30 MB | Tech: Python

30 MB RAMPythonDocker

Self-hosted, ad-free, privacy-respecting Google search proxy. No JavaScript, no ads, no tracking, no AMP.

Architecture

User --> Whoogle (:5000) --> Google Search
              |
         Strip Ads
         Strip Tracking
         No JS
         No AMP

Docker Compose

services:
  whoogle:
    image: benbusby/whoogle-search:latest
    container_name: whoogle
    environment:
      WHOOGLE_CONFIG_LANGUAGE: lang_en
      WHOOGLE_CONFIG_COUNTRY: US
    ports:
      - "5000:5000"
    restart: unless-stopped

Caddy Reverse Proxy

search.example.com {
  reverse_proxy whoogle:5000
}

Security Hardening

Restrict to VPN access
Use HTTPS only
Set search language/country
Rate limit requests

Backup Strategy

Stateless - no data to backup.

Health Check

curl -s http://localhost:5000/healthz

💻 code-server

RAM: ~150 MB | Tech: Node.js

150 MB RAMNode.jsDocker

Full VS Code in browser. Code from anywhere - tablet, phone, Chromebook. IDE in the cloud.

Architecture

User --> code-server (:8080) --> VS Code
              |
         Extensions
         Terminal
         Git
         File Editor

Docker Compose

services:
  code-server:
    image: codercom/code-server:latest
    container_name: code-server
    environment:
      PASSWORD: changeme
      SUDO_PASSWORD: changeme
    volumes:
      - ./code-server-data:/home/coder/.local
      - ./projects:/home/coder/project
    ports:
      - "8080:8080"
    restart: unless-stopped

Caddy Reverse Proxy

code.example.com {
  reverse_proxy code-server:8080
}

Security Hardening

Strong password or OIDC auth
Restrict to VPN
Limit installed extensions
Regular workspace backups
Use HTTPS only

Backup Strategy

Backup code-server-data/ and projects/ directories

Health Check

curl -s http://localhost:8080/healthz

☁ RSS Bridge

RAM: ~20 MB | Tech: PHP

20 MB RAMPHPDocker

Generate RSS feeds for sites that dont have them. Follow YouTube, Twitter, subreddits, any website as RSS. 300+ bridges built-in.

Architecture

User --> RSS Bridge (:3000) --> Source Sites
              |
         300+ Bridges
         Feed Generation
         Caching

Docker Compose

services:
  rss-bridge:
    image: rssbridge/rss-bridge:latest
    container_name: rss-bridge
    volumes:
      - ./rss-bridge-config:/config
    ports:
      - "3000:80"
    restart: unless-stopped

Caddy Reverse Proxy

rss.example.com {
  reverse_proxy rss-bridge:3000
}

Security Hardening

Restrict enabled bridges
Set cache duration
Rate limit requests
Use HTTPS

Backup Strategy

Stateless mostly. Backup rss-bridge-config/ for custom settings.

Health Check

curl -s http://localhost:3000/ | grep -q 'RSS-Bridge'

📓 Linkding

RAM: ~10 MB | Tech: Python

10 MB RAMPythonDocker

Minimal bookmark manager with clean fast UI. Tag-based org, search, import/export, browser extension.

Architecture

User --> Linkding (:9090) --> SQLite DB
              |
         Tags
         Search
         Import/Export

Docker Compose

services:
  linkding:
    image: sissbruecker/linkding:latest
    container_name: linkding
    volumes:
      - ./linkding-data:/etc/linkding/data
    ports:
      - "9090:9090"
    restart: unless-stopped

Caddy Reverse Proxy

bookmarks.example.com {
  reverse_proxy linkding:9090
}

Security Hardening

Enable user auth
Use HTTPS
Regular exports
Rate limit API

Backup Strategy

Backup linkding-data/ directory (SQLite DB)

Health Check

curl -s http://localhost:9090/bookmarks/

VPS Project Specs: Creative and Unique

Jump to Project

🏠 Homer Dashboard

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📊 Homepage Dashboard

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

💾 Syncthing

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📚 KoReader Sync Server

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

🎵 Navidrome

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📷 PhotoPrism

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📺 Jellyfin

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📻 Readeck

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

💬 Conduit (Matrix Server)

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

🔊 Mumble

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

🧩 Wiki.js

Architecture

Docker Compose

Caddy Reverse Proxy

Security Hardening

Backup Strategy

Health Check

📝 DokuWiki