Templates

Templates are the golden paths of the Prangana platform. Each template is a versioned, production-ready blueprint that defines how a service is created — including its repository structure, CI/CD pipeline, Kubernetes manifests, and parameter schema.

Templates are stored in the Prangana Registry and served to Nexus via the Registry API.

tip

To provision a service from a template, see the Provision a service guide. To browse templates in Nexus, navigate to Templates in the sidebar or use the Command palette (Cmd K → type the template name).

Template structure

Field	Description
id	Unique template identifier
name	Machine-readable name (e.g. nodejs-api)
title	Human-readable title (e.g. "Node.js API")
description	What the template creates
owner	Team or individual responsible for the template
type	Template category (e.g. api, web, job, infrastructure)
versions	Array of available versions

Template versions

Each template can have multiple versions. A version contains:

Field	Description
version	Version string (e.g. v1)
title	Version-specific title
description	What this version creates
runtimeOptions	Supported runtimes (e.g. ["node18", "node20"])
parameterSchema	JSON Schema defining the parameters this version accepts
parameterDefaults	Default values for parameters
uiSchema	UI hints for rendering the parameter form
parameterCount	Number of parameters
stepCount	Number of provisioning steps
hasSkeleton	Whether the template includes a code skeleton
hasDefaults	Whether default parameter values are provided
hasSchema	Whether a parameter schema is defined

Available templates

The Prangana Registry ships with the following built-in templates:

Template	Type	Description
nodejs-api	API	Node.js REST API with TypeScript, health checks, and Kubernetes manifests
nodejs-web-app	Web	Next.js web application with Tailwind CSS and Kubernetes deployment
fullstack-nextjs	Web	Full-stack Next.js application with API routes and Kubernetes deployment
python-api	API	FastAPI Python service with Docker and Kubernetes support
java-spring-boot-api	API	Spring Boot Java API with Maven, health endpoints, and K8s manifests
dotnet-api	API	.NET 8 minimal API with Docker and Kubernetes deployment
go-api	API	Go HTTP API with Docker multi-stage build and Kubernetes manifests
postgres-api	API	Python FastAPI with PostgreSQL integration and Docker Compose
azure-function	Function	Azure Functions Python app with timer and HTTP triggers
servicebus-consumer	Job	Azure Service Bus consumer in Python with Kubernetes deployment
k8s-cronjob	Job	Kubernetes CronJob with Python worker and configurable schedule
event-driven	Job	Event-driven worker service with message broker integration
worker-service	Job	Long-running background worker service with Kubernetes deployment
terraform-module	Infrastructure	Reusable Terraform module with variable definitions and pipeline

Template skeleton

Each template with hasSkeleton: true includes a complete code skeleton that is scaffolded into a new Git repository when a service is provisioned. The skeleton includes:

• Application source code
• Dockerfile for containerization
• Kubernetes manifests (deployment.yaml, service.yaml)
• CI/CD pipeline definitions (Azure Pipelines and GitLab CI)
• mkdocs.yml for service documentation
• catalog-info.yaml for service catalog registration
• values.schema.json for parameter validation

Parameter schema

Template parameters are defined using JSON Schema. When you provision a service, Nexus renders a form from the schema and validates your input before submitting to Fabric.

Common parameters across templates:

Parameter	Description
serviceName	Name of the service — used as the repository name and Kubernetes resource name
cloudProvider	Target cloud (azure, gcp, aws)
region	Deployment region
namespace	Kubernetes namespace
replicaCount	Number of pod replicas
containerPort	Port the container listens on

Example parameter schema

{
  "type": "object",
  "required": ["serviceName", "namespace"],
  "properties": {
    "serviceName": {
      "type": "string",
      "title": "Service name",
      "description": "Used as the repository name and Kubernetes resource name"
    },
    "namespace": {
      "type": "string",
      "title": "Kubernetes namespace",
      "default": "default"
    },
    "replicaCount": {
      "type": "integer",
      "title": "Replica count",
      "default": 2,
      "minimum": 1,
      "maximum": 10
    },
    "containerPort": {
      "type": "integer",
      "title": "Container port",
      "default": 3000
    }
  }
}

Template parameter form not showing fields?

If the parameter form is empty, the selected template version does not have a parameterSchema (hasSchema: false). Try selecting a different version — look for versions with the schema badge on the Templates page. See Troubleshooting for more details.

Registry API

Operation	Description
List templates	GET /api/registry/templates

The registry endpoint does not require authentication — it reads directly from the template catalog on the server.

Example: Registry response

{
  "registryRoot": "TemplateRegistry/templates",
  "templateCount": 14,
  "templates": [
    {
      "id": "nodejs-api",
      "name": "nodejs-api",
      "title": "Node.js API",
      "description": "Production-ready Node.js REST API with TypeScript",
      "owner": "platform-team",
      "type": "api",
      "versions": [
        {
          "version": "v1",
          "title": "Node.js API v1",
          "runtimeOptions": ["node18", "node20"],
          "parameterCount": 6,
          "stepCount": 5,
          "hasSkeleton": true,
          "hasDefaults": true,
          "hasSchema": true
        }
      ]
    }
  ]
}