---
title: Templates
description: Deploy a ready-made stack such as n8n, OpenClaw or a Next.js app with its database, and see what each template creates before anything exists.
section: Templates
order: 1
updated: 2026-11-04
---

A template is a [dekka.yaml blueprint](/docs/config-as-code#describe-a-whole-environment-in-dekkayaml) that describes a working stack, so one deploy gives you the services, databases, volumes, variables and connections it needs. Some templates run open-source tools such as n8n, OpenClaw and Uptime Kuma from their published images, and others start a framework app from Dekka's example repositories.

## Find a template

Choose **Templates** in the dashboard's sidebar to browse the library by category or search it. On a project's canvas, choose **Add**, then **Template or dekka.yaml**, to open the same library with the current environment already chosen. The public [template gallery](/templates) shows every template without signing in.

Each template's page shows what it creates as a small diagram, the values you need to provide, the secrets Dekka generates, the volume and memory each service gets, and links to the upstream project.

## Deploy a template

1. Open the template and choose the project and environment it goes into. You can also create a new project from here.
2. Fill in its inputs. Secret inputs, such as API keys, are masked as you type, and required ones are marked.
3. Choose **Review changes**. Dekka plans the template and lists everything it will create, and nothing exists yet.
4. Choose **Deploy**, which names how many changes it applies, to create it all. The services appear on the canvas as they come up.

A plan works like any other set of [staged changes](/docs/staged-changes), so you can leave it and come back, or discard it.

## Inputs and generated secrets

Inputs are values only you can provide, such as an OpenRouter key for Hermes Agent. A required input left empty stops the plan with `missing_input`, which names each one, and an optional input left empty leaves its variable unset.

Generated secrets are values the template creates for itself, such as n8n's encryption key or OpenClaw's gateway token. Dekka generates each one when you plan, stores it as a secret, and never shows it in the plan. Secret inputs are stored the same way. To read a value later, open the service's variables on the **Environment** tab and press and hold it, which is recorded in your organisation's **Activity**.

A generated secret that a template keeps as a shared variable, such as `N8N_ENCRYPTION_KEY`, is created once and kept on every later plan, because the data it protects would become unreadable if it changed.

## Memory, volumes and plan limits

Templates set the memory each service needs, and many community tools need more than the Free plan's 256 MiB per service. n8n, Hermes Agent, Umami, Uptime Kuma and Meilisearch need 512 MiB, which Starter allows, and OpenClaw, Open WebUI, LiteLLM, Flowise and Metabase need 1 GiB, which needs Growth. Plan limits are checked when you deploy, so a template over your plan's limits plans normally and then answers 403 `entitlement_exceeded` with the limit it would pass. [Plans and limits](/docs/limits) lists every figure.

A service with a volume gets a 1 GB [volume](/docs/volumes) at the path its software expects, and runs a single replica. Volumes can grow later but never shrink.

## Third-party software

Community templates run software that Dekka doesn't make or maintain. Each template names its licence and links to the upstream project, and the software's own terms apply to how you use it. n8n, for example, uses the Sustainable Use License, which limits some commercial uses.

> [!NOTE]
> During the pilot, deploys run on a simulated engine. Templates plan, deploy and show build logs, variables and volumes as they would in production, but the services don't run and their URLs don't serve the software.

## Deploy a template with the API

`GET /v1/catalog/templates` lists every template with its metadata, inputs, generated secrets and resources, and needs no API key. Add `?category=ai` to filter it. Planning takes the inputs by key and returns a changeset.

```bash tab="cURL"
curl https://api.dekka.cloud/v1/environments/$ENVIRONMENT_ID/templates/hermes-agent/plan \
  -H "Authorization: Bearer $DEKKA_API_KEY" \
  --json '{ "inputs": { "OPENROUTER_API_KEY": "sk-or-…" } }'
```

Read the planned changes in the response, then deploy the changeset by its `id`.

```bash tab="cURL"
curl https://api.dekka.cloud/v1/changesets/$CHANGESET_ID/deploy \
  -H "Authorization: Bearer $DEKKA_API_KEY" \
  --json '{ "confirm": true }'
```

A template only adds, so planning it where a resource of the same name already exists answers 409 `name_taken`. An input the template doesn't declare answers 422 `unknown_input`.

## Every template

| Template | What it runs | Category |
| --- | --- | --- |
| [`n8n`](/docs/n8n) | Workflow automation with Postgres | Automation |
| [`n8n-workers`](/docs/n8n#run-n8n-with-workers) | n8n in queue mode with a worker and Redis | Automation |
| [`openclaw`](/docs/openclaw) | A personal AI assistant for your chat apps | AI |
| [`hermes-agent`](/docs/hermes-agent) | Nous Research's agent with an OpenAI-compatible API | AI |
| `open-webui` | A chat interface using models through the AI Gateway | AI |
| `litellm` | An OpenAI-compatible proxy in front of many providers | AI |
| `flowise` | A visual builder for AI agents and LLM workflows | AI |
| `umami` | Website analytics without cookies | Analytics |
| `metabase` | Dashboards and questions over your data | Analytics |
| `uptime-kuma` | Uptime monitoring and status pages | Monitoring |
| `meilisearch` | A typo-tolerant search engine | Search |
| `nextjs-postgres` | A Next.js app with Postgres | Frameworks |
| `fastapi-postgres-redis` | A FastAPI service with Postgres and Redis | Frameworks |
| `django-postgres` | A Django site with Postgres | Frameworks |
| `node-worker-queue` | A Node.js worker with a managed queue | Frameworks |
| `node-worker-redis` | A Node.js worker with Redis | Frameworks |
| `s3-bucket` | A private S3-compatible bucket | Storage |

The framework templates start from Dekka's example repositories, so point each service at your own repository in its settings once it exists. To make your own, see [Writing templates](/docs/writing-templates).