Choosing Your Deployment Model

chant covers the synthesis step — TypeScript in, validated artifacts out — and the lifecycle layers built on top of it: Ops, the lifecycle dial, and the component release model. Knowing which layer fits your situation avoids unnecessary setup.

Use none of the lifecycle layers and chant is a deterministic compiler you hand off from — no executor, no state file, nothing to run. The orchestration layer is Temporal-native when you want durability and zero-dependency when you don’t: the local executor runs Ops in-process, and only gated or destructive applies need a Temporal cluster.

Choosing your deployment model

Hand Off to an Existing Pipeline

chant build produces spec-native artifacts (CloudFormation, GitLab CI, Kubernetes manifests, etc.) and hands them off. Deployment happens however it always has: a CI pipeline, ArgoCD, Terraform, a manual kubectl apply. Nothing else to install — the lifecycle layers below simply go unused.

Use this when:

• You already have a deployment pipeline you trust
• You want to adopt typed, linted IaC without changing operational tooling
• Your deployments are short-running or trivially retried from scratch

How to get started: Quick Start — the entire guide covers this hand-off path.

# The complete picture when you hand off to your own tooling
chant build
kubectl apply -f dist/infra.yaml   # or whatever your tooling does next

Ops — Durable Deployment Workflows

Ops are named, phased deployment workflows declared in *.op.ts files. chant build compiles each Op into a Temporal worker. chant run <name> starts the worker and submits the workflow to Temporal.

deploy.op.ts

import { Op, phase, kubectlApply, shell } from "@intentius/chant-lexicon-temporal";

export default Op({
  name: "api-deploy",
  phases: [
    phase("Infra", [kubectlApply("dist/infra.yaml", { profile: "longInfra" })]),
    phase("App",   [kubectlApply("dist/k8s.yaml")]),
    phase("Smoke", [shell("kubectl rollout status deployment/api")]),
  ],
  onFailure: [
    phase("Rollback", [shell("kubectl delete -f dist/infra.yaml --ignore-not-found")]),
  ],
});

chant run api-deploy

You get: live phase progress in the Temporal UI, automatic retry on activity failure, onFailure phases run if the workflow terminates with an error, and gate steps that pause the workflow until a human or external system sends a signal.

Use this when:

• Deployments take more than a few minutes
• You want to see current phase and history without grepping logs
• Some steps need to pause for human approval or an external event (DNS delegation, change-window approval)
• You want automatic rollback on failure without scripting it yourself

How to get started: Quick Start for synthesis, then the Ops guide for Op authoring and chant run. Requires a Temporal server or Temporal Cloud (free tier available).

Components — Release Model

When you have many releasable units — services, tables, clusters, libraries — and don’t want a hand-maintained pipeline per unit, declare each as a *.component.ts component. A component says what it builds, what it produces, and how it deploys, composed from a bounded capability set. chant build generates one generic orchestrator Op that runs them in dependency order; chant run --components <name> runs one. Adding a component adds a declaration, not a pipeline. Supply-chain attestations — SBOM, SLSA provenance, keyless signing — attach to the artifact, and a verify step gates apply.

Use this when:

• You deploy many units off-cluster and each currently drags its own pipeline
• You want build-once / publish-by-digest with SBOM, signing, and a verify gate
• You want rollback via per-capability compensation instead of hand-written scripts

How to get started: Components Overview, then Component Contract. Runs on the local executor by default; only gated or crash-resumable components need Temporal. For where this sits against Ops and the lifecycle dial, see Components.

Raw Temporal + chant

You write your own Temporal workflow TypeScript — signals, queries, updates, parallel activities — and use chant-synthesized YAML as the input those activities operate on. This is the approach shown in the Temporal Workflow-Driven Deploy tutorial.

// Your own Temporal workflow
export async function deployWorkflow(params: DeployParams): Promise<void> {
  await applySharedInfra(params);           // activity calls kubectl apply on chant-built YAML
  await Promise.all([
    applyRegionalInfra(params, 'east'),     // parallel activities with heartbeat
    applyRegionalInfra(params, 'central'),
    applyRegionalInfra(params, 'west'),
  ]);
  setHandler(dnsSignal, () => { dnsReady = true; });
  await condition(() => dnsReady, '48h');   // gate step — signal or auto-detect
  // ...
}

Use this when:

• You’re already running Temporal and have existing workers or workflow patterns
• You need signal/query/update patterns, search attributes, or schedule triggers that Op phases don’t expose
• You want full control over retry policies, heartbeat intervals, and workflow determinism

How to get started: Temporal Workflow-Driven Deploy tutorial.

Note

Ops and raw Temporal are not mutually exclusive. A project can have *.op.ts files for standard deploys and a bespoke workflow for a complex one-off operation. Both consume the same chant-built artifacts.

Decision Table

Situation	Model
I have ArgoCD / Terraform / an existing deploy pipeline	Hand off (existing pipeline)
My deployment script is more than 50 lines and fails unpredictably	Ops
I need a human approval gate mid-deploy	Ops
I have many deployable units each dragging its own pipeline	Components
I want build-once, SBOM + signing, and a verify gate before apply	Components
I need parallel regional deploys with independent retry	Ops or raw Temporal
I’m already a Temporal shop with existing workers	Raw Temporal
I need custom Temporal search attributes or schedules	Raw Temporal
I need workflow-level queries during a running deploy	Raw Temporal (or Op + MCP op-status)