From cb2c6d6d2f8e12dced44466205c7108eb1f1137d Mon Sep 17 00:00:00 2001 From: Krystie Date: Wed, 7 Oct 2026 08:42:26 -0700 Subject: [PATCH] [grade=A] SEO expansion: generated sitemap (14->108 URLs) + RSS feed + 4 keyword articles + 77-app catalog hub --- package.json | 1 + public/feed.xml | 108 ++++ public/sitemap.xml | 568 +++++++++++++++++- scripts/generate-sitemap.mjs | 142 +++++ src/app/blog/[slug]/page.tsx | 11 +- src/app/layout.tsx | 3 + .../blog/access-self-hosted-apps-remotely.md | 90 +++ .../blog/docker-container-management.md | 136 +++++ .../blog/docker-dashboard-self-hosted.md | 63 ++ src/content/blog/manifest.ts | 80 +++ .../blog/one-click-docker-deployment.md | 94 +++ .../blog/self-hosted-app-catalog-guide.md | 171 ++++++ .../blog/self-hosting-platform-guide.md | 111 ++++ src/content/blog/what-is-dashcaddy.md | 78 +++ src/content/blog/why-self-host-benefits.md | 133 ++++ 15 files changed, 1773 insertions(+), 16 deletions(-) create mode 100644 public/feed.xml create mode 100644 scripts/generate-sitemap.mjs create mode 100644 src/content/blog/access-self-hosted-apps-remotely.md create mode 100644 src/content/blog/docker-container-management.md create mode 100644 src/content/blog/docker-dashboard-self-hosted.md create mode 100644 src/content/blog/one-click-docker-deployment.md create mode 100644 src/content/blog/self-hosted-app-catalog-guide.md create mode 100644 src/content/blog/self-hosting-platform-guide.md create mode 100644 src/content/blog/what-is-dashcaddy.md create mode 100644 src/content/blog/why-self-host-benefits.md diff --git a/package.json b/package.json index b002542..682ef16 100644 --- a/package.json +++ b/package.json @@ -4,6 +4,7 @@ "private": true, "scripts": { "dev": "next dev", + "prebuild": "node scripts/generate-sitemap.mjs", "build": "next build", "start": "next start", "lint": "eslint" diff --git a/public/feed.xml b/public/feed.xml new file mode 100644 index 0000000..3c80684 --- /dev/null +++ b/public/feed.xml @@ -0,0 +1,108 @@ + + + + DashCaddy Blog + https://dashcaddy.net/blog/ + Self-hosting deep-dives, product updates, and practical guides to running your own infrastructure. + en-us + + + Docker Dashboard for Self-Hosted Apps: Why DashCaddy Beats Portainer + https://dashcaddy.net/blog/docker-dashboard-self-hosted/ + https://dashcaddy.net/blog/docker-dashboard-self-hosted/ + Wed, 07 Oct 2026 00:00:00 GMT + Compare DashCaddy vs Portainer for managing self-hosted Docker containers. Learn about AI-powered deployment, automatic SSL, and multi-host management. + + + What is DashCaddy? The AI-Powered Self-Hosting Platform Explained + https://dashcaddy.net/blog/what-is-dashcaddy/ + https://dashcaddy.net/blog/what-is-dashcaddy/ + Wed, 07 Oct 2026 00:00:00 GMT + Learn what DashCaddy is—an AI-native platform for deploying, securing, and managing self-hosted applications with plain English commands. + + + Self-Hosted Docker Container Management Made Simple + https://dashcaddy.net/blog/docker-container-management/ + https://dashcaddy.net/blog/docker-container-management/ + Wed, 07 Oct 2026 00:00:00 GMT + Master Docker container management in your homelab. Compare methods, learn best practices, and discover how DashCaddy simplifies running containers. + + + Why Self-Host Your Applications? The Complete Benefits Guide + https://dashcaddy.net/blog/why-self-host-benefits/ + https://dashcaddy.net/blog/why-self-host-benefits/ + Wed, 07 Oct 2026 00:00:00 GMT + Discover why self-hosting your applications saves money, improves privacy, and gives you control. Learn what's possible when you run your own services. + + + How to Access Self-Hosted Apps Remotely (Without Exposing Your Network) + https://dashcaddy.net/blog/access-self-hosted-apps-remotely/ + https://dashcaddy.net/blog/access-self-hosted-apps-remotely/ + Wed, 07 Oct 2026 00:00:00 GMT + Port forwarding, VPNs, and private networks compared. Learn the safe way to reach self-hosted apps from anywhere, and how to scope a service to your own devices. + + + One-Click Docker Deployment: From Blank Server to Running App + https://dashcaddy.net/blog/one-click-docker-deployment/ + https://dashcaddy.net/blog/one-click-docker-deployment/ + Wed, 07 Oct 2026 00:00:00 GMT + What one-click Docker deployment really involves — image, volumes, ports, DNS, TLS, and health checks — and how to get all of it in a single action. + + + Self-Hosting Platform: What It Is and How to Choose One in 2026 + https://dashcaddy.net/blog/self-hosting-platform-guide/ + https://dashcaddy.net/blog/self-hosting-platform-guide/ + Wed, 07 Oct 2026 00:00:00 GMT + A self-hosting platform turns a bare Linux server into somewhere you can run apps safely. Learn the categories, the questions that matter, and how to pick one. + + + 77 Self-Hosted Apps You Can Install in One Click (Full Catalog) + https://dashcaddy.net/blog/self-hosted-app-catalog-guide/ + https://dashcaddy.net/blog/self-hosted-app-catalog-guide/ + Wed, 07 Oct 2026 00:00:00 GMT + A complete map of the 77 apps DashCaddy can deploy in one click — media, files, photos, DNS, security, databases, automation and more, each with its own install guide. + + + Homelab Monitoring: Know When a Docker Service Goes Down + https://dashcaddy.net/blog/homelab-monitoring-guide/ + https://dashcaddy.net/blog/homelab-monitoring-guide/ + Tue, 06 Oct 2026 00:00:00 GMT + Build practical homelab monitoring across hosts, Docker, application health, DNS, HTTPS, and backups, with DashCaddy as the operating view. + + + Homelab Reverse Proxy Guide: HTTPS, DNS, and Caddy + https://dashcaddy.net/blog/homelab-reverse-proxy-guide/ + https://dashcaddy.net/blog/homelab-reverse-proxy-guide/ + Tue, 06 Oct 2026 00:00:00 GMT + Learn how a homelab reverse proxy connects DNS, HTTPS, Caddy, and private services—and how DashCaddy reduces repeated configuration work. + + + 15 Best Self-Hosted Apps for Your Homelab in 2026 + https://dashcaddy.net/blog/best-self-hosted-apps-homelab/ + https://dashcaddy.net/blog/best-self-hosted-apps-homelab/ + Tue, 06 Oct 2026 00:00:00 GMT + Discover 15 useful self-hosted apps for media, photos, files, automation, monitoring, and privacy—all available in DashCaddy's app catalog. + + + Best Homelab Dashboard: What to Look For in 2026 + https://dashcaddy.net/blog/best-homelab-dashboard/ + https://dashcaddy.net/blog/best-homelab-dashboard/ + Tue, 06 Oct 2026 00:00:00 GMT + Compare homelab dashboard types and learn which deployment, health, HTTPS, security, and automation features make a home server easier to manage. + + + How to Build a Homelab: A Beginner's Home Server Guide + https://dashcaddy.net/blog/homelab-beginners-guide/ + https://dashcaddy.net/blog/homelab-beginners-guide/ + Tue, 06 Oct 2026 00:00:00 GMT + Learn how to build a homelab from spare hardware, Docker, DNS, HTTPS, monitoring, and backups—and see how DashCaddy simplifies the work. + + + Deploy Self-Hosted Apps From Plain English: DashCaddy's AI Intent Router + https://dashcaddy.net/blog/deploy-self-hosted-apps-with-ai/ + https://dashcaddy.net/blog/deploy-self-hosted-apps-with-ai/ + Mon, 05 Oct 2026 00:00:00 GMT + How DashCaddy turns a plain-English request into a running, SSL-secured container — 77 one-click app templates, an MCP server for AI assistants, and 400+ registered REST route handlers. + + + diff --git a/public/sitemap.xml b/public/sitemap.xml index 7bead98..37da2ce 100644 --- a/public/sitemap.xml +++ b/public/sitemap.xml @@ -1,17 +1,557 @@ -https://dashcaddy.net/weekly1.0 -https://dashcaddy.net/features/monthly0.9 -https://dashcaddy.net/pricing/monthly0.8 -https://dashcaddy.net/docs/weekly0.9 -https://dashcaddy.net/docs/installation/monthly0.9 -https://dashcaddy.net/docs/catalog/weekly0.8 -https://dashcaddy.net/about/monthly0.7 -https://dashcaddy.net/blog/weekly0.9 -https://dashcaddy.net/blog/deploy-self-hosted-apps-with-ai/monthly0.8 -https://dashcaddy.net/blog/homelab-beginners-guide/monthly0.8 -https://dashcaddy.net/blog/best-homelab-dashboard/monthly0.8 -https://dashcaddy.net/blog/best-self-hosted-apps-homelab/monthly0.8 -https://dashcaddy.net/blog/homelab-reverse-proxy-guide/monthly0.8 -https://dashcaddy.net/blog/homelab-monitoring-guide/monthly0.8 + + https://dashcaddy.net/ + weekly + 1.0 + + + https://dashcaddy.net/about/ + monthly + 0.6 + + + https://dashcaddy.net/blog/ + weekly + 0.9 + + + https://dashcaddy.net/blog/access-self-hosted-apps-remotely/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/best-homelab-dashboard/ + 2026-10-06 + monthly + 0.8 + + + https://dashcaddy.net/blog/best-self-hosted-apps-homelab/ + 2026-10-06 + monthly + 0.8 + + + https://dashcaddy.net/blog/deploy-self-hosted-apps-with-ai/ + 2026-10-05 + monthly + 0.8 + + + https://dashcaddy.net/blog/docker-container-management/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/docker-dashboard-self-hosted/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/homelab-beginners-guide/ + 2026-10-06 + monthly + 0.8 + + + https://dashcaddy.net/blog/homelab-monitoring-guide/ + 2026-10-06 + monthly + 0.8 + + + https://dashcaddy.net/blog/homelab-reverse-proxy-guide/ + 2026-10-06 + monthly + 0.8 + + + https://dashcaddy.net/blog/one-click-docker-deployment/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/self-hosted-app-catalog-guide/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/self-hosting-platform-guide/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/what-is-dashcaddy/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/blog/why-self-host-benefits/ + 2026-10-07 + monthly + 0.8 + + + https://dashcaddy.net/docs/ + weekly + 0.9 + + + https://dashcaddy.net/docs/api/ + monthly + 0.7 + + + https://dashcaddy.net/docs/catalog/ + weekly + 0.8 + + + https://dashcaddy.net/docs/catalog/actual-budget/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/adminer/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/airsonic/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/audiobookshelf/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/authentik/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/bazarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/bind9/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/bookstack/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/calibre-web/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/changedetection/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/coredns/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/crowdsec/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/dashca/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/digital-clock/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/dozzle/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/drone/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/emby/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/excalidraw/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/filebrowser/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/gitea/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/grafana/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/homarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/homeassistant/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/homepage/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/immich/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/it-tools/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/jdownloader/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/jellyfin/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/jenkins/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/kavita/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/komga/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/lidarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/mailserver/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/matrix/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/mealie/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/minecraft/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/mongodb/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/navidrome/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/nextcloud/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/nodered/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/nzbget/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/outline/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/paperless-ngx/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/photoprism/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/pihole/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/plex/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/portainer/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/postgres/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/powerdns/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/prowlarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/qbittorrent/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/radarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/readarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/redis/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/rocketchat/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/roundcube/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/sabnzbd/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/sami-files/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/seerr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/sonarr/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/speedtest/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/standardnotes/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/stirling-pdf/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/syncthing/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/tautulli/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/technitium/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/transmission/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/trilium/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/uptime-kuma/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/valheim/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/vaultwarden/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/vintage-radio/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/vscode-server/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/watchtower/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/weather/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/whoami/ + monthly + 0.6 + + + https://dashcaddy.net/docs/catalog/wireguard/ + monthly + 0.6 + + + https://dashcaddy.net/docs/desktop-app/ + monthly + 0.7 + + + https://dashcaddy.net/docs/first-service/ + monthly + 0.7 + + + https://dashcaddy.net/docs/installation/ + monthly + 0.7 + + + https://dashcaddy.net/docs/integrations/ + monthly + 0.7 + + + https://dashcaddy.net/docs/overview/ + monthly + 0.7 + + + https://dashcaddy.net/docs/premium/ + monthly + 0.7 + + + https://dashcaddy.net/docs/troubleshooting/ + monthly + 0.7 + + + https://dashcaddy.net/features/ + weekly + 0.9 + + + https://dashcaddy.net/policies/privacy/ + yearly + 0.3 + + + https://dashcaddy.net/policies/terms/ + yearly + 0.3 + + + https://dashcaddy.net/pricing/ + weekly + 0.8 + diff --git a/scripts/generate-sitemap.mjs b/scripts/generate-sitemap.mjs new file mode 100644 index 0000000..d9f789b --- /dev/null +++ b/scripts/generate-sitemap.mjs @@ -0,0 +1,142 @@ +#!/usr/bin/env node +/** + * Generate public/sitemap.xml and public/feed.xml from the real route tree + * and the blog manifest. + * + * Runs automatically before `next build` (see the "prebuild" npm script), so + * the deployed sitemap can never drift from the pages that actually exist. + * Fails loudly if the blog manifest cannot be parsed, rather than silently + * emitting a partial sitemap. + */ +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); +const APP_DIR = path.join(root, "src", "app"); +const MANIFEST = path.join(root, "src", "content", "blog", "manifest.ts"); +const PUBLIC_DIR = path.join(root, "public"); +const ORIGIN = "https://dashcaddy.net"; +const SITE_DESCRIPTION = + "Self-hosting deep-dives, product updates, and practical guides to running your own infrastructure."; + +// Pages that must never be advertised to crawlers. +const EXCLUDE = new Set(["/success/", "/404/", "/500/"]); + +function walk(dir) { + const found = []; + for (const entry of fs.readdirSync(dir, { withFileTypes: true })) { + const full = path.join(dir, entry.name); + if (entry.isDirectory()) found.push(...walk(full)); + else if (entry.name === "page.tsx") found.push(full); + } + return found; +} + +function routeFor(file) { + const rel = path.relative(APP_DIR, path.dirname(file)); + const parts = rel + .split(path.sep) + .filter((part) => part && part !== "." && !/^\(.*\)$/.test(part)); + // Dynamic segments ([slug]) are expanded from data sources, not enumerated. + if (parts.some((part) => part.startsWith("["))) return null; + return "/" + parts.join("/") + (parts.length ? "/" : ""); +} + +function meta(route) { + if (route === "/") return { priority: "1.0", changefreq: "weekly" }; + if (route === "/blog/" || route === "/docs/" || route === "/features/") + return { priority: "0.9", changefreq: "weekly" }; + if (route === "/pricing/" || route === "/docs/catalog/") + return { priority: "0.8", changefreq: "weekly" }; + if (route.startsWith("/docs/catalog/")) return { priority: "0.6", changefreq: "monthly" }; + if (route.startsWith("/docs/")) return { priority: "0.7", changefreq: "monthly" }; + if (route === "/about/") return { priority: "0.6", changefreq: "monthly" }; + if (route.startsWith("/policies/")) return { priority: "0.3", changefreq: "yearly" }; + return { priority: "0.5", changefreq: "monthly" }; +} + +function xmlEscape(value) { + return value + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """); +} + +// --- Blog manifest --------------------------------------------------------- +const manifestSrc = fs.readFileSync(MANIFEST, "utf8"); + +const POSTS = [ + ...manifestSrc.matchAll( + /\{\s*slug:\s*"([^"]+)",\s*title:\s*"((?:[^"\\]|\\.)*)",\s*description:\s*"((?:[^"\\]|\\.)*)",\s*date:\s*"([^"]+)"/g + ), +].map((m) => ({ slug: m[1], title: m[2], description: m[3], date: m[4] })); + +const manifestSlugCount = [...manifestSrc.matchAll(/slug:\s*"([^"]+)"/g)].length; +if (POSTS.length === 0 || POSTS.length !== manifestSlugCount) { + throw new Error( + `generate-sitemap: parsed ${POSTS.length} posts but manifest declares ${manifestSlugCount} slugs — refusing to emit a partial sitemap` + ); +} + +// --- Sitemap --------------------------------------------------------------- +const staticRoutes = [...new Set(walk(APP_DIR).map(routeFor).filter(Boolean))] + .filter((route) => !EXCLUDE.has(route)) + .sort(); + +const urls = [ + ...staticRoutes.map((route) => ({ loc: ORIGIN + route, ...meta(route) })), + ...POSTS.map((post) => ({ + loc: `${ORIGIN}/blog/${post.slug}/`, + lastmod: post.date, + changefreq: "monthly", + priority: "0.8", + })), +].sort((a, b) => (a.loc < b.loc ? -1 : 1)); + +const sitemap = + `\n` + + `\n` + + urls + .map( + (u) => + ` \n ${u.loc}` + + (u.lastmod ? `\n ${u.lastmod}` : "") + + `\n ${u.changefreq}\n ${u.priority}\n ` + ) + .join("\n") + + `\n\n`; + +// --- RSS feed -------------------------------------------------------------- +const sortedPosts = [...POSTS].sort((a, b) => (a.date < b.date ? 1 : -1)); + +const feed = + `\n` + + `\n \n` + + ` DashCaddy Blog\n` + + ` ${ORIGIN}/blog/\n` + + ` ${xmlEscape(SITE_DESCRIPTION)}\n` + + ` en-us\n` + + ` \n` + + sortedPosts + .map( + (p) => + ` \n` + + ` ${xmlEscape(p.title)}\n` + + ` ${ORIGIN}/blog/${p.slug}/\n` + + ` ${ORIGIN}/blog/${p.slug}/\n` + + ` ${new Date(`${p.date}T00:00:00Z`).toUTCString()}\n` + + ` ${xmlEscape(p.description)}\n` + + ` ` + ) + .join("\n") + + `\n \n\n`; + +fs.mkdirSync(PUBLIC_DIR, { recursive: true }); +fs.writeFileSync(path.join(PUBLIC_DIR, "sitemap.xml"), sitemap); +fs.writeFileSync(path.join(PUBLIC_DIR, "feed.xml"), feed); + +console.log( + `generate-sitemap: ${urls.length} sitemap URLs (${staticRoutes.length} pages + ${POSTS.length} posts), ${sortedPosts.length} feed items` +); \ No newline at end of file diff --git a/src/app/blog/[slug]/page.tsx b/src/app/blog/[slug]/page.tsx index 492020b..6b3763c 100644 --- a/src/app/blog/[slug]/page.tsx +++ b/src/app/blog/[slug]/page.tsx @@ -38,10 +38,14 @@ function getPost(slug: string) { return POSTS.find((p) => p.slug === slug) ?? null; } +function stripFrontmatter(markdown: string): string { + return markdown.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, ""); +} + function readBody(slug: string): string | null { const file = path.join(BLOG_DIR, `${slug}.md`); if (!fs.existsSync(file)) return null; - return fs.readFileSync(file, "utf8"); + return stripFrontmatter(fs.readFileSync(file, "utf8")); } function formatDate(iso: string): string { @@ -64,7 +68,10 @@ export async function generateMetadata({ return { title: `${post.title} — DashCaddy Blog`, description: post.description, - alternates: { canonical: `https://dashcaddy.net/blog/${post.slug}/` }, + alternates: { + canonical: `https://dashcaddy.net/blog/${post.slug}/`, + types: { "application/rss+xml": "https://dashcaddy.net/feed.xml" }, + }, keywords: post.tags, authors: [{ name: post.author }], openGraph: { diff --git a/src/app/layout.tsx b/src/app/layout.tsx index d58b81a..a446f1f 100644 --- a/src/app/layout.tsx +++ b/src/app/layout.tsx @@ -30,6 +30,9 @@ export const metadata: Metadata = { description: "Deploy 77 Docker apps with one click. AI-powered self-hosting.", }, + alternates: { + types: { "application/rss+xml": "https://dashcaddy.net/feed.xml" }, + }, }; // Inline script to set theme class BEFORE first paint — prevents FOUC diff --git a/src/content/blog/access-self-hosted-apps-remotely.md b/src/content/blog/access-self-hosted-apps-remotely.md new file mode 100644 index 0000000..2420206 --- /dev/null +++ b/src/content/blog/access-self-hosted-apps-remotely.md @@ -0,0 +1,90 @@ +--- +title: "How to Access Self-Hosted Apps Remotely (Without Exposing Your Network)" +description: "Port forwarding, VPNs, and private networks compared. Learn the safe way to reach self-hosted apps from anywhere, and how to scope a service to your own devices." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["access self-hosted apps remotely", "remote access homelab", "tailscale homelab", "secure remote access", "self-hosted vpn"] +readingMinutes: 8 +--- + +A self-hosted app you cannot reach from outside your house is a hobby. The moment you can open it from a phone on cellular data, it becomes infrastructure. The difference between those two states is one honest decision about **how** you expose it. + +Get that decision right and you have a service. Get it wrong and you have an open port on your home network and a very long weekend. + +## The three ways to reach a self-hosted app + +### 1. Port forwarding + +You forward a port on your router to the server, and the app is on the public internet. + +**Pros:** works from any device, no client software, no third party. +**Cons:** you have now published a service to the entire internet. Anything unpatched, misconfigured, or weakly authenticated is fair game. You also need a public IP, which many connections no longer provide. + +Port forwarding is not automatically wrong — public sites need it. But it should be a deliberate decision for a service you intend to be public, not the default for your dashboard. + +### 2. A VPN back into your network + +You run WireGuard or OpenVPN on your server and connect to it from your devices. Once connected, you are effectively on your LAN. + +**Pros:** nothing is exposed except the VPN port; strong cryptography; you reach every service at once. +**Cons:** your traffic routes through home while connected, the VPN endpoint itself is public, and per-device onboarding gets tedious as the device count grows. + +This is the classic answer and it is a good one. Its weak point is that the tunnel is all-or-nothing: connected means *everything* is reachable. + +### 3. A private mesh network + +Tools like Tailscale and Headscale build an encrypted peer-to-peer network between your devices and servers, without opening ports at all. Each machine gets a stable private address. + +**Pros:** no inbound ports to open; works behind NAT and CGNAT; identity-based access controls; you can share one service with one person instead of the whole network. +**Cons:** it is a managed overlay (unless you self-host the control plane), and you should understand the trust model before you rely on it. + +For most homelabs in 2026, this is the best default for private services — and it pairs well with a public reverse proxy for the few services that genuinely need to be public. + +## The rule that keeps you out of trouble + +**Expose deliberately, per service. Never expose a whole machine by accident.** + +Every service should have an answer to: "who is allowed to reach this, and from where?" The common failure is a platform that treats *everything* as public the moment it is deployed. The correct behavior is a per-service choice: + +- **Private** — reachable only from your own devices over the private network. +- **Restricted** — reachable from the internet, but only from specified IP ranges or behind an identity provider. +- **Public** — reachable by anyone, which should be a short and intentional list. + +## How DashCaddy handles this + +DashCaddy's deploy options map directly onto that rule, which is why they are worth knowing before you expose anything: + +- **Private-network scoping.** A service can be restricted to your private network so it never appears on the public proxy at all. For a dashboard, an admin panel, or a database UI, this is the right default. +- **Allowed IP ranges.** When a service must be reachable from outside, you can permit specific CIDR ranges rather than the whole internet. +- **Automatic HTTPS.** Services that *are* public still get a real certificate, so you are not trading security for convenience. +- **A security surface.** The Security Center exists so the answer to "what is exposed right now?" is a screen you can look at, not a guess. + +These are per-deployment settings, not global switches — so exposing one service never quietly exposes the rest. The [installation docs](/docs/installation/) cover the dashboard, and the [catalog guides](/docs/catalog/) document the deploy payload per app; the [WireGuard template](/docs/catalog/wireguard/) is there if you prefer to build your own tunnel instead of using a mesh network. + +## A practical setup, start to finish + +1. **Install DashCaddy** on the host that will run your private services. +2. **Join your devices to a private network.** Install Tailscale (or point clients at your own Headscale) on your laptop, phone, and the server. +3. **Deploy private services with network scoping on.** Your dashboard, monitoring, and admin tools should not be public. Ever. +4. **Pick the one or two services that must be public** — a media server for the family, a photo server you share with a relative — and deploy those normally so they get a certificate and a real URL. +5. **Verify from outside.** Turn off Wi-Fi on your phone. The private services should be reachable over the private network; the public ones should load at their URL; nothing else should answer. + +That five-step sequence gets you remote access without a port-forwarding free-for-all. + +## Mistakes worth avoiding + +- **Forwarding 443 to a whole host.** You publish every service that host runs, including the ones you forgot about. +- **Relying on "nobody knows the URL."** Security by obscurity fails the first time a certificate transparency log is read. +- **Leaving an admin UI on the public internet.** Dashboards, database admin tools, and container managers belong on the private network. +- **Forgetting the renewal.** A private setup with an expired certificate trains you to click through warnings, which is exactly the habit that gets people phished. +- **No monitoring on the remote path.** Remote access that silently stops working is worse than none — see the [homelab monitoring guide](/blog/homelab-monitoring-guide/) for what to watch. + +## Getting started + +Install DashCaddy on any Linux host: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Then deploy something, scope it to your private network, and confirm you can reach it from your phone with Wi-Fi off. If you are still choosing what to run, the [full catalog](/blog/self-hosted-app-catalog-guide/) and the [best self-hosted apps roundup](/blog/best-self-hosted-apps-homelab/) are good next reads, and [one-click Docker deployment](/blog/one-click-docker-deployment/) explains what happens during a deploy. \ No newline at end of file diff --git a/src/content/blog/docker-container-management.md b/src/content/blog/docker-container-management.md new file mode 100644 index 0000000..7e0ca1c --- /dev/null +++ b/src/content/blog/docker-container-management.md @@ -0,0 +1,136 @@ +--- +title: "Self-Hosted Docker Container Management Made Simple" +description: "Master Docker container management in your homelab. Compare methods, learn best practices, and discover how DashCaddy simplifies running containers." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["docker container", "container management", "homelab docker", "docker-compose", "docker swarm"] +readingMinutes: 7 +--- + +Docker has become the backbone of modern self-hosting. Whether you're running a media server, a home automation system, or personal cloud storage, containers make deployment and management significantly easier. + +## Understanding Docker Container Basics + +Before diving into management tools, let's cover the fundamentals: + +### What Are Containers? + +Containers are lightweight, standalone packages that include everything needed to run software: code, runtime, libraries, and system settings. Unlike virtual machines, containers share the host OS kernel, making them much more efficient. + +### Key Docker Concepts + +- **Image** — A read-only template for creating containers +- **Container** — A running instance of an image +- **Volume** — Persistent storage outside containers +- **Network** — How containers communicate +- **Compose** — Multi-container definitions + +## Methods for Managing Docker Containers + +### 1. Command Line (Docker CLI) + +The native approach: +```bash +docker run -d --name jellyfin jellyfin/jellyfin +docker ps +docker logs jellyfin +``` + +**Pros:** Full control, no extra software +**Cons:** Steep learning curve, manual everything + +### 2. Portainer + +Web-based GUI for Docker: +```bash +docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer +``` + +**Pros:** Visual interface, container inspection +**Cons:** Manual SSL setup, basic multi-host support + +### 3. CasaOS + +User-friendly homelab OS: +```bash +curl -fsSL https://get.casaos.io | bash +``` + +**Pros:** Extremely simple, good for beginners +**Cons:** Limited customization, few advanced features + +### 4. DashCaddy + +AI-powered container management: +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Then deploy with plain English: +> "Set up Jellyfin for my media library" + +**Pros:** AI automation, automatic SSL, reverse proxy, multi-host +**Cons:** Newer project, smaller template library + +## Best Practices for Container Management + +### Resource Limits + +Always set memory and CPU limits: +```yaml +services: + jellyfin: + image: jellyfin/jellyfin + deploy: + resources: + limits: + memory: 4G + cpus: '2.0' +``` + +### Health Checks + +DashCaddy includes built-in health monitoring. For manual setups: +```yaml +healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8096/health"] + interval: 30s + timeout: 10s + retries: 3 +``` + +### Regular Updates + +Keep containers updated: +```bash +docker-compose pull +docker-compose up -d +``` + +DashCaddy handles this automatically across your fleet. + +### Backup Strategy + +Always back up: +- Volumes (your data) +- Docker Compose files (your configuration) +- Environment variables (secrets) + +## Why DashCaddy for Container Management? + +1. **Plain English Deployment** — No more copying docker-compose files +2. **Automatic SSL** — HTTPS out of the box +3. **Reverse Proxy Built-In** — No manual Nginx/Caddy config +4. **Multi-Host** — Manage all your servers from one dashboard +5. **AI Assistance** — Ask questions, get help with configuration + +## Get Started + +Ready to simplify your Docker management? + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Then try: "Deploy Jellyfin" and watch it happen automatically. + diff --git a/src/content/blog/docker-dashboard-self-hosted.md b/src/content/blog/docker-dashboard-self-hosted.md new file mode 100644 index 0000000..caddf02 --- /dev/null +++ b/src/content/blog/docker-dashboard-self-hosted.md @@ -0,0 +1,63 @@ +--- +title: "Docker Dashboard for Self-Hosted Apps: Why DashCaddy Beats Portainer" +description: "Compare DashCaddy vs Portainer for managing self-hosted Docker containers. Learn about AI-powered deployment, automatic SSL, and multi-host management." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["docker dashboard", "portainer alternative", "self-hosted docker", "docker management", "container management"] +readingMinutes: 8 +--- + +Managing Docker containers shouldn't require a computer science degree. Whether you're running a homelab with a few containers or managing a fleet of production servers, the right Docker dashboard makes all the difference. + +## Why Self-Hosted Docker Management Matters + +Running self-hosted applications gives you control over your data, privacy, and costs. But managing those applications through the command line gets old fast. That's where Docker dashboards come in. + +Popular options include: +- **Portainer** — the longtime favorite for container management +- **CasaOS** — user-friendly but limited +- **DashCaddy** — newer entrant with AI-powered features + +## DashCaddy vs Portainer: Feature Comparison + +| Feature | DashCaddy | Portainer | +|---------|------------|-----------| +| AI-Powered Deployment | ✓ Plain English | ✗ Manual | +| Automatic SSL | ✓ Built-in | ✓ Via Caddy | +| Multi-Host Fleet | ✓ Yes | ✓ Business tier | +| App Templates | 77 one-click | 100+ | +| MCP Server | ✓ For AI agents | ✗ | +| Reverse Proxy | Automatic | Manual | + +## Plain English Deployment + +Here's where DashCaddy stands out. Instead of clicking through configuration screens, you can deploy apps using natural language: + +> "Deploy Jellyfin with automatic SSL and make it accessible at media.mydomain.com" + +DashCaddy understands intent, configures DNS, issues SSL certificates, and sets up the reverse proxy—all automatically. + +## When to Choose Portainer + +Portainer remains excellent for: +- Organizations already invested in Portainer +- Teams needing fine-grained container inspection +- Scenarios requiring legacy Docker Compose support + +## When DashCaddy Wins + +DashCaddy shines when you want: +- **Speed** — Deploy apps in seconds, not minutes +- **Simplicity** — No manual reverse proxy configuration +- **AI integration** — MCP server for automation +- **Multi-host management** — Single dashboard for your entire fleet + +## Getting Started + +Install DashCaddy on any Linux server: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Then access the dashboard at `http://your-server:3000` to start deploying apps with plain English commands. diff --git a/src/content/blog/manifest.ts b/src/content/blog/manifest.ts index d9c8afa..7119b64 100644 --- a/src/content/blog/manifest.ts +++ b/src/content/blog/manifest.ts @@ -14,6 +14,86 @@ export interface PostMeta { } export const POSTS: PostMeta[] = [ + { + slug: "self-hosted-app-catalog-guide", + title: "77 Self-Hosted Apps You Can Install in One Click (Full Catalog)", + description: + "A complete map of the 77 apps DashCaddy can deploy in one click — media, files, photos, DNS, security, databases, automation and more, each with its own install guide.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["self-hosted apps", "docker app catalog", "self-hosted app list", "one-click apps", "homelab apps"], + readingMinutes: 9, + }, + { + slug: "self-hosting-platform-guide", + title: "Self-Hosting Platform: What It Is and How to Choose One in 2026", + description: + "A self-hosting platform turns a bare Linux server into somewhere you can run apps safely. Learn the categories, the questions that matter, and how to pick one.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["self-hosting platform", "self hosted platform", "self-hosting software", "docker platform", "homelab"], + readingMinutes: 8, + }, + { + slug: "one-click-docker-deployment", + title: "One-Click Docker Deployment: From Blank Server to Running App", + description: + "What one-click Docker deployment really involves — image, volumes, ports, DNS, TLS, and health checks — and how to get all of it in a single action.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["one-click docker deployment", "deploy docker app", "docker deployment tool", "docker templates", "docker install"], + readingMinutes: 7, + }, + { + slug: "access-self-hosted-apps-remotely", + title: "How to Access Self-Hosted Apps Remotely (Without Exposing Your Network)", + description: + "Port forwarding, VPNs, and private networks compared. Learn the safe way to reach self-hosted apps from anywhere, and how to scope a service to your own devices.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["access self-hosted apps remotely", "remote access homelab", "tailscale homelab", "secure remote access", "self-hosted vpn"], + readingMinutes: 8, + }, + { + slug: "why-self-host-benefits", + title: "Why Self-Host Your Applications? The Complete Benefits Guide", + description: + "Discover why self-hosting your applications saves money, improves privacy, and gives you control. Learn what's possible when you run your own services.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["self-hosting benefits", "why self-host", "homelab advantages", "privacy", "data ownership"], + readingMinutes: 7, + }, + { + slug: "docker-container-management", + title: "Self-Hosted Docker Container Management Made Simple", + description: + "Master Docker container management in your homelab. Compare methods, learn best practices, and discover how DashCaddy simplifies running containers.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["docker container", "container management", "homelab docker", "docker-compose", "docker swarm"], + readingMinutes: 7, + }, + { + slug: "what-is-dashcaddy", + title: "What is DashCaddy? The AI-Powered Self-Hosting Platform Explained", + description: + "Learn what DashCaddy is—an AI-native platform for deploying, securing, and managing self-hosted applications with plain English commands.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["what is dashcaddy", "self-hosting platform", "AI self-hosting", "docker deployment", "automated ssl"], + readingMinutes: 6, + }, + { + slug: "docker-dashboard-self-hosted", + title: "Docker Dashboard for Self-Hosted Apps: Why DashCaddy Beats Portainer", + description: + "Compare DashCaddy vs Portainer for managing self-hosted Docker containers. Learn about AI-powered deployment, automatic SSL, and multi-host management.", + date: "2026-10-07", + author: "DashCaddy Team", + tags: ["docker dashboard", "portainer alternative", "self-hosted docker", "docker management", "container management"], + readingMinutes: 8, + }, { slug: "homelab-beginners-guide", title: "How to Build a Homelab: A Beginner's Home Server Guide", diff --git a/src/content/blog/one-click-docker-deployment.md b/src/content/blog/one-click-docker-deployment.md new file mode 100644 index 0000000..e349738 --- /dev/null +++ b/src/content/blog/one-click-docker-deployment.md @@ -0,0 +1,94 @@ +--- +title: "One-Click Docker Deployment: From Blank Server to Running App" +description: "What one-click Docker deployment really involves — image, volumes, ports, DNS, TLS, and health checks — and how to get all of it in a single action." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["one-click docker deployment", "deploy docker app", "docker deployment tool", "docker templates", "docker install"] +readingMinutes: 7 +--- + +"One-click deploy" sounds like marketing until you have done the manual version. Then it sounds like a description of a very long list of things you no longer have to do. + +This article breaks down what actually happens between "I want to run Immich" and "Immich is live at a real URL with a valid certificate" — and why doing it by hand is where most homelab evenings go. + +## The nine things that happen when you deploy a container + +A container is the easy part. Everything around it is the work: + +1. **Pick the image and pin it.** `:latest` is convenient and occasionally a surprise. A platform should know the image it is going to pull. +2. **Decide the persistent paths.** Which directories must survive a container rebuild? Get this wrong and your photo library lives inside a container that disappears on the next update. +3. **Map ports.** Host port 8080 is taken. Again. +4. **Set environment variables and secrets.** Database passwords, admin users, API tokens, claim tokens. +5. **Create or attach a network.** So the container can talk to its database and nothing else it should not. +6. **Write a reverse-proxy entry.** Caddy or Nginx config that routes `app.example.com` to the right container port. +7. **Create the DNS record.** The subdomain has to resolve, and it has to resolve to the right host. +8. **Issue and install a TLS certificate.** Then renew it forever. +9. **Wait for a health check.** "Started" is not "working." The container can be running and still return 500s. + +You can do all nine by hand. People do. It is also the reason so many homelabs have a service that has been "almost done" since March. + +## What "one-click" should mean + +A deployment button that only covers step 1 is not one-click; it is `docker run` with a nicer font. Genuine one-click deployment covers the whole list, in order, with a real result at the end: a URL that opens, over HTTPS, with a green health check. + +DashCaddy's deploy path does exactly that. You pick a template from the [app catalog](/docs/catalog/), fill in the few values that are genuinely yours (a subdomain, maybe a media path or a claim token), and press Deploy. DashCaddy then: + +- pulls the pinned image; +- creates the persistent volumes; +- attaches the container to its network; +- writes the reverse-proxy route; +- creates the DNS record; +- issues the certificate; +- and polls the app's health endpoint before reporting success. + +If the health check does not pass, you get a failure — not a container that is technically running and practically broken. + +## The same deploy, two ways + +Every template is available through the dashboard and through the REST API. The API path is what makes automation possible. A deploy is a single authenticated POST whose body names the app and the handful of settings that matter: + +```bash +curl -X POST https://your-host/api/v1/apps/deploy \ + -H "X-API-Key: " \ + -H "Content-Type: application/json" \ + -d '{ + "appId": "immich", + "config": { "subdomain": "photos" } + }' +``` + +Because the endpoint is a normal REST route, the same call works from a shell script, a CI job, or an AI assistant connected over the [MCP server](/blog/deploy-self-hosted-apps-with-ai/). The install guides in the catalog document the exact payload for each app — see the [Plex guide](/docs/catalog/plex/) or the [Jellyfin guide](/docs/catalog/jellyfin/) for the pattern. + +## Where manual deployment still makes sense + +Automation is not a religion. Reach for the manual path when: + +- you are **evaluating** a new app and want to poke at it without a permanent footprint; +- the image needs a **custom build** or a patch the template does not cover; +- you are **debugging** and need to run the container with different flags than the template uses. + +That is also why a platform should let you **attach to an existing container** rather than forcing every service to be born inside it. DashCaddy supports adopting an already-running container so existing work is not thrown away. + +## A deployment checklist that fits on a napkin + +Whatever tool you use, verify these five things after the first deploy: + +- **The URL opens over HTTPS** with a valid, non-self-signed certificate. +- **The data path is a host directory you recognize** — check with `docker inspect` if unsure. +- **The DNS record is yours** and points where you think it does. +- **The health check is green**, not merely "running." +- **A restart brings it back.** `reboot` the host and confirm the service returns without you. + +If all five hold, you have done real one-click deployment, regardless of which tool did it. + +## Getting started + +Install DashCaddy on any Linux host: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Then open the dashboard, browse the [catalog](/docs/catalog/), and deploy something. The [installation docs](/docs/installation/) cover host requirements, and [First Service](/docs/first-service/) walks through the very first deploy in detail. + +Once the first app is up, the natural next questions are [how to access it remotely](/blog/access-self-hosted-apps-remotely/) and [how to know when it goes down](/blog/homelab-monitoring-guide/). \ No newline at end of file diff --git a/src/content/blog/self-hosted-app-catalog-guide.md b/src/content/blog/self-hosted-app-catalog-guide.md new file mode 100644 index 0000000..38fcef0 --- /dev/null +++ b/src/content/blog/self-hosted-app-catalog-guide.md @@ -0,0 +1,171 @@ +--- +title: "77 Self-Hosted Apps You Can Install in One Click (Full Catalog)" +description: "A complete map of the 77 apps DashCaddy can deploy in one click — media, files, photos, DNS, security, databases, automation and more — each with an install guide." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["self-hosted apps", "docker app catalog", "self-hosted app list", "one-click apps", "homelab apps"] +readingMinutes: 9 +--- + +The hardest part of a homelab is rarely the hardware. It is deciding what to run, then discovering that "install it" hides six more steps. + +This page is the complete, current map of what DashCaddy deploys in one click: **77 application templates across 17 categories**, each with a dedicated install guide covering prerequisites, the exact deploy payload, and post-install verification. Every link below goes to that app's guide. + +Everything here is deployable from the dashboard, from the REST API, or through the MCP server. + +## Media (10) + +Stream, read, and listen to your own library — no subscription, no regional licensing, no vendor deciding what you are allowed to own. + +- [Plex](/docs/catalog/plex/) — stream your personal media collection anywhere +- [Jellyfin](/docs/catalog/jellyfin/) — free software media system, an alternative to Plex +- [Emby](/docs/catalog/emby/) — personal media server with apps for all devices +- [Audiobookshelf](/docs/catalog/audiobookshelf/) — self-hosted audiobook and podcast server +- [Navidrome](/docs/catalog/navidrome/) — modern music server and streamer +- [Calibre-Web](/docs/catalog/calibre-web/) — browse and read your ebook library in a browser +- [Kavita](/docs/catalog/kavita/) — fast, cross-platform manga and comic reader +- [Komga](/docs/catalog/komga/) — comics and manga server with a clean web reader +- [Airsonic Advanced](/docs/catalog/airsonic/) — stream your music collection to any device +- [Vintage Stereo](/docs/catalog/vintage-radio/) — a retro-styled internet radio player + +## Media Management (8) + +The tooling that turns a folder of files into an organized library. + +- [Seerr](/docs/catalog/seerr/) — request management for your media stack +- [Sonarr](/docs/catalog/sonarr/) — TV series collection management +- [Radarr](/docs/catalog/radarr/) — movie collection management +- [Lidarr](/docs/catalog/lidarr/) — music collection management +- [Readarr](/docs/catalog/readarr/) — book collection management +- [Prowlarr](/docs/catalog/prowlarr/) — indexer manager for the whole stack +- [Bazarr](/docs/catalog/bazarr/) — automatic subtitle management +- [Tautulli](/docs/catalog/tautulli/) — monitoring and statistics for Plex + +## Downloads (5) + +- [qBittorrent](/docs/catalog/qbittorrent/) — feature-rich BitTorrent client with a web UI +- [Transmission](/docs/catalog/transmission/) — lightweight, no-fuss torrent client +- [SABnzbd](/docs/catalog/sabnzbd/) — Usenet downloader +- [NZBGet](/docs/catalog/nzbget/) — efficient Usenet binary downloader +- [JDownloader 2](/docs/catalog/jdownloader/) — download manager for file hosts + +## Photos (2) + +- [Immich](/docs/catalog/immich/) — self-hosted photo and video backup, the open answer to Google Photos +- [PhotoPrism](/docs/catalog/photoprism/) — AI-powered photo organization and search + +## Files (3) + +- [FileBrowser](/docs/catalog/filebrowser/) — a web file manager for a directory on your server +- [Syncthing](/docs/catalog/syncthing/) — continuous peer-to-peer file synchronization +- [Sami Files](/docs/catalog/sami-files/) — a multi-server file manager for your fleet + +## Productivity (9) + +- [Nextcloud](/docs/catalog/nextcloud/) — the complete self-hosted productivity and file platform +- [Paperless-ngx](/docs/catalog/paperless-ngx/) — index, search, and archive your documents +- [BookStack](/docs/catalog/bookstack/) — structured wiki and documentation platform +- [Outline](/docs/catalog/outline/) — fast, modern team knowledge base +- [Trilium Notes](/docs/catalog/trilium/) — hierarchical personal knowledge base +- [Standard Notes](/docs/catalog/standardnotes/) — encrypted notes with a long-term focus +- [Mealie](/docs/catalog/mealie/) — recipe manager and meal planner +- [Actual Budget](/docs/catalog/actual-budget/) — local-first personal budgeting +- [Excalidraw](/docs/catalog/excalidraw/) — hand-drawn-style virtual whiteboard + +## Development (4) + +- [Gitea](/docs/catalog/gitea/) — lightweight self-hosted Git service +- [VS Code Server](/docs/catalog/vscode-server/) — a full VS Code instance in the browser +- [Jenkins](/docs/catalog/jenkins/) — automation server for builds and pipelines +- [Drone CI](/docs/catalog/drone/) — container-native continuous integration + +## Management (2) + +- [Portainer](/docs/catalog/portainer/) — the well-known Docker container dashboard +- [Watchtower](/docs/catalog/watchtower/) — automatic container image updates + +## Monitoring (4) + +- [Uptime Kuma](/docs/catalog/uptime-kuma/) — self-hosted uptime and alerting +- [Grafana](/docs/catalog/grafana/) — dashboards and visualization for your metrics +- [Dozzle](/docs/catalog/dozzle/) — live container log viewer +- [Speedtest Tracker](/docs/catalog/speedtest/) — scheduled internet speed monitoring + +## Networking (2) + +- [Pi-hole](/docs/catalog/pihole/) — network-wide ad and tracker blocking +- [WireGuard VPN](/docs/catalog/wireguard/) — fast, modern VPN tunnels + +## DNS (4) + +- [Technitium DNS Server](/docs/catalog/technitium/) — authoritative and recursive DNS in one +- [BIND9 DNS Server](/docs/catalog/bind9/) — the classic, battle-tested nameserver +- [PowerDNS](/docs/catalog/powerdns/) — high-performance authoritative DNS +- [CoreDNS](/docs/catalog/coredns/) — plugin-based DNS server + +## Communication (4) + +- [Rocket.Chat](/docs/catalog/rocketchat/) — self-hosted team chat +- [Matrix Synapse](/docs/catalog/matrix/) — decentralized, federated messaging +- [Roundcube](/docs/catalog/roundcube/) — webmail for your own mail server +- [Docker Mailserver](/docs/catalog/mailserver/) — a full mail stack in one container + +## Home Automation (2) + +- [Home Assistant](/docs/catalog/homeassistant/) — local-first home automation +- [Node-RED](/docs/catalog/nodered/) — flow-based automation wiring + +## Database (4) + +- [PostgreSQL](/docs/catalog/postgres/) — the reliable relational workhorse +- [Redis](/docs/catalog/redis/) — in-memory key-value store and cache +- [MongoDB](/docs/catalog/mongodb/) — document database for modern apps +- [Adminer](/docs/catalog/adminer/) — a single-file database admin UI + +## Security (4) + +- [Vaultwarden](/docs/catalog/vaultwarden/) — a lightweight Bitwarden-compatible password manager +- [Authentik](/docs/catalog/authentik/) — identity provider and single sign-on +- [CrowdSec](/docs/catalog/crowdsec/) — collaborative, behavior-based intrusion prevention +- [DashCA](/docs/catalog/dashca/) — internal certificate authority + +## Utilities (8) + +- [Homepage](/docs/catalog/homepage/) — a modern dashboard for all your services +- [Homarr](/docs/catalog/homarr/) — a customizable service dashboard +- [IT Tools](/docs/catalog/it-tools/) — a collection of everyday developer utilities +- [Stirling PDF](/docs/catalog/stirling-pdf/) — the web-based PDF toolbox +- [Change Detection](/docs/catalog/changedetection/) — watch any web page for changes +- [Whoami](/docs/catalog/whoami/) — a tiny container that reports request details +- [Digital Clock](/docs/catalog/digital-clock/) — a simple always-on clock display +- [Weather](/docs/catalog/weather/) — a self-hosted weather page + +## Gaming (2) + +- [Minecraft Server](/docs/catalog/minecraft/) — a managed Minecraft Java server +- [Valheim Server](/docs/catalog/valheim/) — a dedicated Valheim world for you and your friends + +## Why a catalog beats five tabs of documentation + +Categories matter more than they look. They are what turn "I have some containers" into "I know what my server does." Grouping the same services makes it obvious when something is missing — no monitoring, no backups, no identity layer — and gives you a natural next thing to add. + +The catalog is also the reason deployment stays consistent. Every template defines its image, its ports, its volumes, and its health check in one place, so a deploy behaves the same way whether it is the first app on the host or the fortieth. The platform takes care of the DNS record, the reverse-proxy entry, and the certificate in the same pass. + +## What to deploy first + +If you are starting from nothing, this order tends to work well: + +1. **A dashboard** — [Homepage](/docs/catalog/homepage/) or [Homarr](/docs/catalog/homarr/) — so you can see everything at once. +2. **Monitoring** — [Uptime Kuma](/docs/catalog/uptime-kuma/) — so you find out when something breaks. +3. **The thing you actually wanted** — photos, media, or files. Deploy it while the setup is fresh. +4. **A password manager** — [Vaultwarden](/docs/catalog/vaultwarden/) — before you have forty logins to track. + +## Getting started + +Install DashCaddy on any Linux host with Docker: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +The [installation docs](/docs/installation/) cover requirements, [First Service](/docs/first-service/) walks through your first deploy, and the [catalog index](/docs/catalog/) lists all 77 apps. If you would rather understand the strategy first, start with [what makes a good self-hosting platform](/blog/self-hosting-platform-guide/) or [the best self-hosted apps for a homelab](/blog/best-self-hosted-apps-homelab/). \ No newline at end of file diff --git a/src/content/blog/self-hosting-platform-guide.md b/src/content/blog/self-hosting-platform-guide.md new file mode 100644 index 0000000..a6ef711 --- /dev/null +++ b/src/content/blog/self-hosting-platform-guide.md @@ -0,0 +1,111 @@ +--- +title: "Self-Hosting Platform: What It Is and How to Choose One in 2026" +description: "A self-hosting platform turns a bare Linux server into a place you can run apps safely. Learn the categories, the questions that actually matter, and how to pick one." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["self-hosting platform", "self hosted platform", "self-hosting software", "docker platform", "homelab"] +readingMinutes: 8 +--- + +If you have ever typed `docker run` on a fresh server, watched it fail because the port was already taken, and then spent an evening editing a reverse-proxy config by hand, you already understand why self-hosting platforms exist. + +A **self-hosting platform** is the layer between your operating system and the applications you want to run. It handles the parts that are boring and easy to get wrong — container lifecycle, networking, DNS records, TLS certificates, storage, and updates — so that "install Nextcloud" becomes one decision instead of twenty. + +This guide explains what these platforms actually do, how the categories differ, and which questions separate a platform you will still be using in a year from one you abandon in a weekend. + +## What a self-hosting platform is (and is not) + +Self-hosting is the act of running software on hardware you control instead of paying a SaaS vendor. A **platform** is the tooling that makes that repeatable. + +It is not the same thing as: + +- **An operating system** — Ubuntu, Debian, or a hypervisor like Proxmox. The platform runs *on top* of these. +- **A hypervisor or VM manager** — that virtualizes machines; a self-hosting platform deploys applications. +- **A single app** — Nextcloud, Jellyfin, and Immich are things you host; the platform is what hosts them. + +In practice, most modern self-hosting platforms are built around Docker. Containers give you isolation and reproducibility for free. What Docker does *not* give you is DNS, HTTPS, backups, an app catalog, or a way to see the health of everything at once — which is exactly the gap a platform fills. + +## The three rough categories + +Most tools you will encounter fall into one of three buckets. + +### 1. Container dashboards + +Lightweight web UIs over the Docker socket. Portainer and similar tools let you start, stop, inspect, and edit containers. + +**Best for:** people who already know Docker and just want a GUI. +**Limit:** they stop at the container. You still wire up reverse proxying, certificates, and DNS yourself. + +### 2. App-launcher OS bundles + +Opinionated distros that ship a curated set of apps with one-click installs, usually on a fixed host. + +**Best for:** a first homelab and a small, predictable app list. +**Limit:** departing from the curated catalog — or adding a second host — often means fighting the abstraction. + +### 3. Full self-hosting platforms + +These combine a catalog, deployment automation, networking and TLS, security controls, monitoring, and multi-host management in one system. They assume you will outgrow a single box and a single app. + +**Best for:** anyone who wants to keep adding services without rebuilding their setup each time. + +DashCaddy is built in this third category: an AI-native platform that deploys from a catalog of 77 one-click application templates, provisions the reverse proxy and certificate for you, and keeps the whole fleet on one dashboard. You can see the full app list in the [catalog](/docs/catalog/) and the operating model in the [docs](/docs/). + +## The questions that actually matter + +Feature checklists are easy to write and rarely decide anything. These five questions do. + +### Can it deploy an app without you touching a config file? + +The test is whether adding a service is a *decision* or a *task*. If you still have to write a Caddy or Nginx block, create a DNS record, and remember the right port mapping every time, the platform is only saving you the `docker run` line. + +With DashCaddy you describe the outcome — "deploy Jellyfin at media.example.com with HTTPS" — and it resolves the container, the DNS record, the reverse-proxy entry, and the certificate. The [AI intent router](/blog/deploy-self-hosted-apps-with-ai/) is the piece that turns plain English into a running container. + +### Does HTTPS happen automatically? + +A self-hosted app without TLS is a liability the moment it is reachable from outside your LAN. Automatic certificate issuance and renewal is table stakes; a platform that leaves it to you is a platform that will eventually serve an expired certificate. + +### Can it grow past one machine? + +Almost everyone starts with one server. Almost everyone who sticks with self-hosting adds a second — a storage box, a media box, a machine for the things that must not go down with the lab. Ask whether the platform has a concept of *hosts*, or whether "adding a server" means starting over. + +### Does it tell you when something breaks? + +The failure mode that hurts is not the crash you notice. It is the service that quietly stops answering on a Saturday and is discovered on Thursday. Health checks, uptime history, and container-level visibility are what turn "I have a homelab" into "I operate a service." See the [homelab monitoring guide](/blog/homelab-monitoring-guide/) for what to actually watch. + +### How does it treat security? + +A platform that exposes Docker and a reverse proxy on the public internet needs an opinion about access control. Look for authentication, network scoping (the ability to restrict a service to a private network such as Tailscale), and a security view that surfaces the state of the exposed surface rather than hiding it. + +## Where DashCaddy fits + +If you are comparing options, here is the honest positioning. + +DashCaddy is a strong fit when: + +- you want to **deploy from a catalog** rather than hand-write Compose files; +- you want **automatic DNS, reverse proxy, and TLS** as part of deployment; +- you expect to run **more than one host**; +- you want an **AI/MCP interface** so assistants and automation can drive deployments; +- you want a **security and monitoring surface** in the same tool you deploy from. + +It is a weaker fit when you need fine-grained, per-container inspection with a long history in exactly one niche workflow, or when you are already deeply standardized on another platform's configuration format. Portainer, for instance, remains excellent for raw container inspection — the comparison in [Docker dashboard for self-hosted apps](/blog/docker-dashboard-self-hosted/) goes into that in detail. + +## A practical way to choose + +1. **Write down the next three apps you actually want to run.** Not the twenty-app wish list — the next three. Then check whether each is supported out of the box. +2. **Check the failure story.** Search the docs for how the platform handles a dead container, a failed certificate, or a disk filling up. Thin answers here predict a painful month three. +3. **Install it once on a throwaway VM.** Not on your main server. Deploy two apps, restart the host, and confirm both come back. That single test rules out most options. +4. **Confirm data lives where you expect.** Containers are disposable; volumes are not. Know where your data is on disk before you trust the platform with it. + +## Getting started + +DashCaddy installs on any Linux host with Docker in one command: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +That gives you a dashboard with the [app catalog](/docs/catalog/), automatic HTTPS, and a security view. From there you can deploy your first service, then add a second host when you are ready — without changing how you work. + +If you are still deciding what to run first, start with the [15 best self-hosted apps](/blog/best-self-hosted-apps-homelab/) or the [beginner's homelab guide](/blog/homelab-beginners-guide/). \ No newline at end of file diff --git a/src/content/blog/what-is-dashcaddy.md b/src/content/blog/what-is-dashcaddy.md new file mode 100644 index 0000000..b3e4c06 --- /dev/null +++ b/src/content/blog/what-is-dashcaddy.md @@ -0,0 +1,78 @@ +--- +title: "What is DashCaddy? The AI-Powered Self-Hosting Platform Explained" +description: "Learn what DashCaddy is—an AI-native platform for deploying, securing, and managing self-hosted applications with plain English commands." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["what is dashcaddy", "self-hosting platform", "AI self-hosting", "docker deployment", "automated ssl"] +readingMinutes: 6 +--- + +If you've ever wanted to self-host your applications but felt overwhelmed by Docker, DNS configuration, SSL certificates, and reverse proxies—DashCaddy is the solution you've been looking for. + +## What Makes DashCaddy Different + +DashCaddy isn't just another Docker management tool. It's an **AI-native self-hosting platform** that lets you deploy applications using plain English commands. + +### Traditional Self-Hosting vs DashCaddy + +**Traditional approach (without DashCaddy):** +1. Research which Docker image to use +2. Write a docker-compose.yml file +3. Configure environment variables +4. Set up DNS A and CNAME records +5. Configure reverse proxy (Nginx, Caddy, or Traefik) +6. Generate or obtain SSL certificates +7. Configure SSL certificates in your reverse proxy +8. Test everything + +**With DashCaddy:** +1. Type: "Deploy Jellyfin for my media server" +2. Done. DNS, SSL, and reverse proxy are automatic. + +## Key Features + +### 77 One-Click App Templates + +DashCaddy includes pre-configured templates for popular self-hosted applications: +- Media servers: Jellyfin, Plex, Emby +- Communication: Matrix, Element, Mattermost +- Productivity: Home Assistant, Paperless-NGX, Firefly III +- And 70+ more + +### AI Intent Router + +The AI analyzes your plain English requests, determines which app you want, and configures everything automatically. + +### Built-in Security Center + +- Automatic SSL via Let's Encrypt +- TOTP two-factor authentication +- Rate limiting +- IP blocking +- Security headers + +### Multi-Host Fleet Management + +Manage multiple servers from a single dashboard. Deploy apps across your entire homelab or production fleet with one command. + +### MCP Server for AI Agents + +Machine Chain Protocol (MCP) server allows AI assistants to manage your infrastructure programmatically. + +## Who Is DashCaddy For? + +- **Homelab enthusiasts** who want easier container management +- **Self-hosters** tired of manual reverse proxy configuration +- **Small businesses** needing simple internal tool deployment +- **Developers** who want infrastructure-as-code without the complexity + +## Try It Now + +Install DashCaddy on any Linux server: + +```bash +curl -fsSL https://get.dashcaddy.net | bash +``` + +Visit [dashcaddy.net](https://dashcaddy.net) to learn more. + diff --git a/src/content/blog/why-self-host-benefits.md b/src/content/blog/why-self-host-benefits.md new file mode 100644 index 0000000..17b833c --- /dev/null +++ b/src/content/blog/why-self-host-benefits.md @@ -0,0 +1,133 @@ +--- +title: "Why Self-Host Your Applications? The Complete Benefits Guide" +description: "Discover why self-hosting your applications saves money, improves privacy, and gives you control. Learn what's possible when you run your own services." +date: "2026-10-07" +author: "DashCaddy Team" +tags: ["self-hosting benefits", "why self-host", "homelab advantages", "privacy", "data ownership"] +readingMinutes: 7 +--- + +The cloud was supposed to simplify everything. And for many years, it did. But as subscription costs rise and privacy concerns grow, more people are asking: why not host our own applications? + +## The Rise of Self-Hosting + +Self-hosting means running your own applications on your own hardware—whether that's a Raspberry Pi in your closet or a dedicated server in a data center. + +## Top Benefits of Self-Hosting + +### 1. Cost Savings + +Cloud subscriptions add up fast: +- Netflix: $15-23/month +- Google One: $10-50/month +- Dropbox: $12/month +- Notion: $10/month +- Slack: $8-15/user/month + +Total: $50-150/month minimum for a small team or family. + +**Self-hosting alternative:** One-time server cost + electricity. Break-even in 6-12 months. + +### 2. Data Privacy + +When you host your own data: +- Your files stay on your hardware +- No third-party access to personal data +- No targeted ads based on your content +- GDPR and compliance headaches disappear + +### 3. Complete Control + +Want to: +- Keep photos forever without deletion limits? +- Run your own chat server? +- Customize every aspect of your tools? +- Never lose access because you missed a payment? + +Self-hosting gives you all this. + +### 4. Learning Opportunity + +Running your own infrastructure teaches: +- Linux administration +- Networking (DNS, SSL, reverse proxies) +- Containerization with Docker +- Security best practices +- Troubleshooting skills + +### 5. No Vendor Lock-In + +Cloud providers can: +- Raise prices overnight +- Change features you rely on +- Shut down entirely (RIP Google Reader, Google+, Inbox) +- Lock you into their ecosystem + +When you self-host, you own your infrastructure. + +### 6. Performance & Reliability + +Your homelab can be: +- Faster than shared cloud (local network) +- More reliable (you control updates) +- Always available (no internet needed for local apps) + +## What Can You Self-Host? + +**Media & Entertainment:** +- Jellyfin/Plex — personal streaming +- Navidrome — music streaming +- Readarr/Booksonic — ebooks/audiobooks + +**Productivity:** +- Nextcloud — Google Drive alternative +- Paperless-NGX — document management +- Firefly III — personal finance + +**Communication:** +- Matrix/Element — Slack/Discord alternative +- Mailu — email server +- Bitwarden — password manager + +**Home Automation:** +- Home Assistant — smart home hub +- AdGuard Home — network-wide ad blocking + +**And 77+ more with DashCaddy.** + +## Common Concerns + +### "It's too hard" + +Tools like DashCaddy make it easy. Plain English deployment, automatic SSL, built-in reverse proxy. + +### "My data isn't backed up" + +You control your backups. Use external drives, rsync to cloud storage, or both. + +### "My server might go down" + +Build redundancy. Multiple drives, UPS backup, or simply accept that occasionally things need maintenance. + +### "I don't have the hardware" + +Start small: +- Raspberry Pi 4: $50-100 +- Old laptop: free +- Mini PC: $100-200 + +## Getting Started with Self-Hosting + +The easiest path: + +1. Get a Linux server (old computer, VPS, or dedicated hardware) +2. Install DashCaddy: `curl -fsSL https://get.dashcaddy.net | bash` +3. Try: "Deploy Nextcloud" or "Set up Jellyfin" + +Within minutes, you'll have running applications that you own. + +## The Future is Self-Hosted + +As cloud costs rise and privacy concerns grow, self-hosting isn't just for geeks anymore. It's for anyone who wants control over their digital life. + +Ready to start? Visit [dashcaddy.net](https://dashcaddy.net) to learn more.