Stop Writing Docker Compose Files! 500+ Portainer Templates Exposed

What if you could deploy any self-hosted application in under 60 seconds—without writing a single line of YAML?

Here's the brutal truth most Docker^{↗ Bright Coding Blog} enthusiasts won't admit: we've been wasting hours crafting Docker Compose files for applications that have already been configured thousands of times. That custom Nextcloud setup? Someone solved it. Your meticulously tuned Plex configuration? There's a template for that. The homelab dashboard you've been tweaking for weekends? Deployed in one click.

The hidden cost isn't just time—it's decision fatigue. Every docker-compose.yml you write is another opportunity for misconfigured volumes, forgotten environment variables, or networking nightmares that only surface at 2 AM. What if the entire self-hosting community had already solved these problems and packaged them into a single, battle-tested collection?

Enter Lissy93/portainer-templates—a curated arsenal of 500+ ready-to-deploy Portainer app templates that's quietly becoming the secret weapon of elite homelab operators and DevOps^{↗ Bright Coding Blog} professionals. This isn't just a list of apps. It's a productivity multiplier that transforms Portainer from a container manager into an application deployment powerhouse.

In this deep dive, I'll expose exactly how this repository works, why it's trending across Reddit and GitHub, and how you can go from zero to fully deployed homelab in minutes—not days. Whether you're managing a single Raspberry Pi or orchestrating a multi-node Docker Swarm, these templates will fundamentally change how you think about application deployment.

What is Lissy93/portainer-templates?

Lissy93/portainer-templates is a meticulously compiled collection of 500+ Portainer-compatible application templates maintained by Alicia Sykes (Lissy93), a prolific open-source contributor known for developer productivity tools. The repository solves a critical gap in the Portainer ecosystem: while Portainer ships with basic templates, they're limited in scope and quickly become stale.

The project's brilliance lies in its aggregation strategy. Rather than maintaining 500+ templates in isolation, Lissy93's repository combines templates from multiple community sources—including xneo1's portainer_templates, pi-hosted, mediadepot, and SelfhostedPro—into a single, unified templates.json file. This means one URL gives you access to the collective wisdom of the entire self-hosting community.

Why it's trending now:

• The self-hosting renaissance: Post-2023, developers increasingly reject SaaS lock-in. Tools like Portainer lower the barrier, but template discovery remains painful.
• Portainer v3 format compatibility: The templates use Portainer's latest specification, ensuring they work across all Portainer versions without deprecation warnings.
• Active maintenance via GitHub Actions: The templates.json file auto-generates from source repositories, meaning new apps appear without manual intervention.
• The companion website: portainer-templates.as93.net provides browsable stats, configuration previews, and standalone installation commands—transforming a JSON file into a searchable application marketplace.

The repository isn't just a static dump. It's a living ecosystem with validation schemas, self-hosting options, and clear contribution pathways. For developers who value infrastructure-as-code but despise repetitive configuration, this represents the holy grail: standardized deployments without sacrificing flexibility.

Key Features That Make This Indispensable

Let's dissect what separates this collection from scattered GitHub gists and forum posts:

Massive Cross-Domain Coverage

The 500+ templates span virtually every self-hosting category imaginable:

• Media Management: Plex, Jellyfin, Sonarr, Radarr, Lidarr, Bazarr, Audiobookshelf
• Productivity & Collaboration: Nextcloud, BookStack, CryptPad, Docmost, Appwrite
• Monitoring & Observability: Uptime Kuma, Beszel, Checkmate, Dashdot, Datadog Agent
• Security & Networking: AdGuard Home, Authelia, Authentik, Cloudflare DDNS, CrowdSec
• Development Tools: Code Server, Dockge, Docker Compose Maker, Codiad
• Financial & Personal: Actual, Cryptofolio, Dawarich (location tracking)
• Infrastructure: Caddy, NGINX, CockroachDB, CrateDB, various databases

Intelligent Template Aggregation

The repository's lib/ directory contains Python^{↗ Bright Coding Blog} scripts that:

1. Parse sources.csv for external template repositories
2. Download and normalize template formats
3. Merge with local templates from sources/local/
4. Validate against Schema.json (Portainer's official specification)
5. Output a single, deduplicated templates.json

This means you get the best of all worlds without managing multiple template URLs.

Flexible Deployment Modes

Templates aren't one-size-fits-all. The collection includes:

• Container deployments: Single Docker containers for simple apps
• Stack deployments: Full Docker Compose configurations for multi-service apps
• Swarm configurations: Production-ready distributed deployments
• Kubernetes manifests: For cloud-native orchestration

Self-Hosting Independence

Don't want to depend on GitHub's CDN? The repository provides:

• A Dockerized NGINX server (lissy93/portainer-templates image)
• Local build instructions with docker build
• Volume mounting for custom templates.json files

This is crucial for air-gapped environments or organizations with strict egress policies.

Quality Assurance Pipeline

Every template undergoes:

• JSON schema validation (make validate)
• Automated generation via GitHub Actions
• Source attribution with issue reporting links
• Community-driven maintenance through fork-friendly architecture

Real-World Use Cases Where These Templates Shine

Scenario 1: The 10-Minute Homelab

You've got a Raspberry Pi 4 and a dream. Previously, you'd spend hours researching compatible images, tweaking compose files, and debugging volume permissions. With these templates:

1. Install Portainer (5 minutes)
2. Add the template URL (30 seconds)
3. Deploy Pi-hole, Home Assistant, and Jellyfin (4 minutes)
4. Configure domains through AdGuard Home (30 seconds)

Result: A fully functional smart home and media server before your coffee gets cold.

Scenario 2: The DevOps Onboarding Accelerator

New team member needs a local development environment matching production? Instead of a 20-page wiki, you:

1. Deploy Code Server for browser-based VS Code
2. Spin up matching database versions (PostgreSQL^{↗ Bright Coding Blog}, Redis, CockroachDB)
3. Add monitoring with Uptime Kuma and Dozzle
4. Include documentation via BookStack

Result: Consistent, reproducible environments without "works on my machine" syndrome.

Scenario 3: The Security-Conscious Self-Hoster

You want defense-in-depth without configuration hell:

• Authelia or Authentik for SSO and 2FA
• AdGuard Home for network-wide ad blocking
• CrowdSec for intrusion detection
• Vaultwarden (Bitwarden RS) for password management
• Docuseal for document signing

All deployable with single clicks, pre-configured for common network topologies.

Scenario 4: The Content Creator's Infrastructure

Podcasters, YouTubers, and streamers need:

• Castopod for podcast hosting
• Chibisafe for file sharing
• Chevereto for image hosting
• ArchiveBox for reference preservation
• Activepieces for marketing automation

Previously requiring separate research and configuration, now deployable in a single afternoon.

Step-by-Step Installation & Setup Guide

Prerequisites

• Docker Engine 20.10+ installed
• Portainer CE or BE running (installation below if needed)
• Network access to raw.githubusercontent.com (or self-hosted alternative)

Installing Portainer (If Fresh Setup)

# Create Docker volume for Portainer data persistence
docker volume create portainer_data

# Deploy Portainer CE with Docker socket access
docker run -d \
  -p 8000:8000 \
  -p 9443:9443 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest

Critical security note: The --restart=always flag ensures Portainer survives host reboots. The Docker socket mount is required for container management—never expose this to untrusted networks.

Adding the Template Repository

This is where the magic happens. Portainer's default templates are intentionally minimal. Here's how to unlock the full catalog:

1. Access Portainer Web UI: Navigate to https://your-host:9443
2. Navigate to Settings: Left sidebar → Settings → App Templates
3. Replace the URL: Clear the default and paste:

   https://raw.githubusercontent.com/Lissy93/portainer-templates/main/templates.json
   

4. Save settings: No restart required

Verification Steps

# Test template URL accessibility from your Portainer host
curl -I https://raw.githubusercontent.com/Lissy93/portainer-templates/main/templates.json

# Expected: HTTP/2 200 with content-type: application/json

Accessing Templates

1. Return to Home → App Templates
2. Browse 500+ applications with logos, descriptions, and one-click deployment
3. Use the search bar for specific apps (e.g., "jellyfin", "vaultwarden")

Alternative: CLI Template Injection

For automated deployments or CI/CD pipelines:

# Start Portainer with template URL pre-configured
docker run -d \
  -p 8000:8000 \
  -p 9443:9443 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest \
  --templates https://raw.githubusercontent.com/Lissy93/portainer-templates/main/templates.json

The --templates flag ensures your template source persists across container recreation.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Lissy93's repository, with detailed explanations of what each component accomplishes.

Example 1: Self-Hosted Template Server

The repository provides a complete Docker-based hosting solution. Here's the exact build and run process from the README:

# Clone the repository to your local machine
git clone https://github.com/lissy93/portainer-templates.git

# Enter the project directory
cd portainer-templates

# Build the Docker image with NGINX serving templates.json
docker build -t portainer-templates .

# Run the container, mapping port 8080 on host to port 80 in container
# The -d flag runs detached, and quotes around port mapping prevent shell expansion issues
docker run -d -p "8080:80" portainer-templates

What's happening here: The Dockerfile (implied by the build context) packages templates.json with an NGINX server. This creates an air-gapped template source—critical for environments without internet access or with strict security policies. Once running, you'd configure Portainer to use http://your-host:8080/templates.json instead of GitHub's CDN.

Production consideration: For HTTPS, place this behind a reverse proxy or modify the Dockerfile to include certbot for Let's Encrypt automation.

Example 2: Custom Template Volume Mount

The README provides this elegant pattern for template customization without forking:

# Run the official image, but mount your custom templates.json
# ${PWD} expands to current directory—ensure templates.json exists here
# The volume mount overwrites the container's default templates.json
docker run -d -p "8080:80" \
  -v "${PWD}/templates.json:/usr/share/nginx/html/templates.json" \
  lissy93/portainer-templates

Why this matters: This pattern enables selective curation. Enterprise users can strip unwanted apps, add internal tools, or inject organization-specific environment variables. The container remains updatable (docker pull lissy93/portainer-templates:latest) while your customizations persist.

Advanced pattern: Combine with Git submodules to version-control your templates.json alongside infrastructure code:

# In your infrastructure repo
git submodule add https://github.com/Lissy93/portainer-templates.git upstream-templates
# Symlink your customized templates
cp upstream-templates/templates.json ./my-templates.json
# Edit my-templates.json, then mount this file in production

Example 3: Template Generation Workflow

The repository's build system uses a Makefile. Here's the validation command:

# Validate your custom templates against Portainer's official schema
# This catches JSON syntax errors, missing required fields, and type mismatches
# BEFORE they break your Portainer instance
make validate

Under the hood: The Makefile likely invokes jsonschema or similar against Schema.json (included in the repository). This schema enforces:

• Required fields: type, title, description
• Valid template types: container, stack, swarm
• Proper image reference formats
• Environment variable definitions
• Volume mount specifications

CI/CD integration: Add make validate to your GitHub Actions or GitLab CI pipeline to prevent broken templates from reaching production.

Example 4: Contributing a New Source

The sources.csv format enables community expansion. While not explicitly shown in the README, the editing section describes this pattern:

# sources.csv format (inferred from documentation)
# name,url
xneo1_templates,https://raw.githubusercontent.com/xneo1/portainer_templates/master/template.json
pi_hosted,https://raw.githubusercontent.com/novaspirit/pi-hosted/master/template/portainer-v2.json
mediadepot,https://raw.githubusercontent.com/mediadepot/templates/master/portainer.json

The aggregation magic: GitHub Actions parse this CSV, fetch each URL, normalize varying JSON structures, deduplicate by application name, and merge into templates.json. This means one maintainer's curation benefits thousands of users.

For template authors: If you maintain Portainer templates, adding your URL to sources.csv via pull request instantly distributes your work to the entire user base.

Advanced Usage & Best Practices

Template Caching Strategy

Portainer fetches templates.json on every UI load. For large deployments:

# Host templates.json on your CDN with aggressive caching
curl -H "Cache-Control: max-age=3600" \
  https://your-cdn.com/templates.json > /dev/null

Environment-Specific Overrides

Create layered template files:

# Base templates (from Lissy93)
cp templates.json templates-base.json

# Add your organization's custom apps
jq '.templates += [{"type":"container","title":"Internal-API",...}]' \
  templates-base.json > templates-production.json

Backup Your Portainer Configuration

# Export Portainer settings including template URL
docker exec portainer /portainer --backup-to /data/backup.tar
docker cp portainer:/data/backup.tar ./portainer-backup-$(date +%Y%m%d).tar

Monitoring Template Health

Deploy Uptime Kuma (available in templates!) to monitor:

• Template URL availability
• Individual application endpoints
• Certificate expiration for HTTPS frontends

Comparison with Alternatives

The verdict: Official templates are stable but sparse. SelfhostedPro offers quality but narrower scope. Manual compose provides unlimited flexibility at enormous time cost. Lissy93's aggregation model delivers the comprehensiveness of manual curation with the convenience of official distribution.

FAQ: Common Developer Concerns

Are these templates safe to use in production?

Templates reference official Docker Hub images where possible. Always verify image sources and pin to specific digests for production. The repository itself doesn't host images—only deployment configurations.

Can I use these with Portainer Business Edition?

Absolutely. The v3 template format is compatible with both CE and BE. BE users gain additional RBAC controls over template access.

What happens if GitHub is down?

This is why the self-hosted option exists. Run docker run -p 8080:80 lissy93/portainer-templates locally and point Portainer to your internal instance.

How do I contribute a new application?

Either add your template JSON to sources/local/ or submit your template repository URL to sources.csv. Run make validate before submitting PRs.

Will these work on ARM devices like Raspberry Pi?

Template compatibility depends on the underlying Docker images. The repository includes ARM-compatible sources (notably pi-hosted). Check individual app pages on portainer-templates.as93.net for architecture badges.

Can I mix these with my existing custom templates?

Yes—Portainer supports multiple template sources, or you can fork this repository and merge your templates into the build pipeline.

How often is templates.json updated?

GitHub Actions triggers on repository changes and on a schedule (typically daily). Check the commit history for exact frequency.

Conclusion: Your Deployment Workflow Will Never Be the Same

The Lissy93/portainer-templates repository represents a fundamental shift in how we approach containerized application deployment. By aggregating community knowledge into validated, one-click configurations, it eliminates the friction that slows homelab enthusiasts and DevOps professionals alike.

What I've learned from extensive use: The real value isn't just time saved—it's cognitive load reduction. When deployment complexity drops to near-zero, you experiment more. You try tools you'd never have configured manually. Your infrastructure becomes genuinely composable.

My recommendation: Start with the hosted template URL for immediate gratification. Once you're convinced (you will be), self-host the template server for resilience. Contribute back when you discover gaps—the aggregation model means your work amplifies across the entire community.

The future of self-hosting isn't writing more YAML. It's curated, validated, instantly deployable application packages. This repository is that future, available today.

Ready to transform your Portainer experience?

👉 Star and explore Lissy93/portainer-templates on GitHub

👉 Browse all 500+ apps at portainer-templates.as93.net

Your next deployment is one click away. Stop configuring. Start building.

Found this guide valuable? Share it with your homelab community, and consider starring the repository to support open-source maintenance.