Development & Deployment Principles

The Talisman Platform is deployed directly within customer premises and private cloud environments, providing complete control over runtime execution, network boundaries, and integration data. Because it runs on customer-managed infrastructure, Talisman flexibly integrates with your chosen ecosystem—whether utilizing internal self-hosted systems, external cloud services (such as GitHub, GitLab, or cloud container registries), or hybrid configurations.

Talisman provides first-class support for both Kubernetes and Docker runtimes across multi-server environments (Dev, Test, Prod). Regardless of your infrastructure footprint or tooling choices, the platform operates on a single core principle: build in development and promote immutable images. An integration is built once into a container image in the development phase and promoted across Test and Production environments. Environment differences remain strictly decoupled from the image: Kubernetes uses a baseline deployment manifest with an environment-specific configuration patch for each environment, while Docker uses an environment-specific Docker configuration referencing the same immutable image. This guarantees that runtime artifacts remain consistent, verified, and unchanged across all stages.

To accommodate different organizational structures, engineering preferences, and DevOps maturity levels, Talisman provides three core developer workflows. Every approach offers distinct advantages, and one workflow does not diminish another—teams are encouraged to select the approach that best aligns with their operational goals.

Development Workflows

Studio Web on Server: A fully web-based workflow operating on a single main branch. Builds, baseline manifest generation for Kubernetes, and environment promotions occur on the Dev Server, while deployments execute on Dev, Test, and Prod servers respectively across Kubernetes and Docker out of the box.
VS Code with Server Build: Combines local IDE development and Git branching with Dev Server builds. The Dev Server synchronizes merged changes from Git, builds the image, and manages promotions to Test and Prod servers for both Kubernetes and Docker out of the box.
VS Code with CI/CD: A fully decoupled automation approach where CI/CD and GitOps platforms manage the lifecycle. Talisman provides Kubernetes pipeline templates for GitHub Actions and Azure Pipelines to build and deploy to Dev, while organizations implement Docker targets and environment promotions within their own pipelines.

Studio Web on Server

This approach offers a frictionless, self-contained experience directly within the deployed platform. Developers design integrations in Talisman Studio Web, while the platform coordinates builds and deployments across dedicated Dev, Test, and Prod servers using Git as the central source of truth. Both Kubernetes and Docker are supported out of the box.

flowchart LR

    subgraph servers [Talisman Servers]
        Dev["Dev"]
        Test["Test"]
        Prod["Prod"]
    end

%%    subgraph infra [Infra]
        Git[("Git")]
        Registry[("Image Registry")]
%%    end

    Dev -->|Code| Git
    Dev -->|Resources| Git
    Dev -->|Images| Registry
    Git -.->|Resources| Test
    Git -.->|Resources| Prod
    Registry -.->|Images| Test
    Registry -.->|Images| Prod

Workflow

Design (Dev): Developers author integrations directly in the Talisman Studio Web interface hosted on the Dev Server, maintaining project changes on the main branch.
Build (Dev): The Dev Server builds and publishes the immutable container image to the container registry. For Kubernetes, the build also generates the baseline deployment manifest in the project, which reaches Git when committed.
Deploy to Dev: The Dev Server deploys the integration to the development environment using the baseline deployment manifest and development configuration patch for Kubernetes, or the development Docker configuration for Docker.
Promote to Test (Dev Server): On the Dev Server, the deployment definition verified on Dev is promoted to Test by pairing it with Test's environment configuration—a configuration patch for Kubernetes or a Docker configuration for Docker—and committing the resources to Git. Test never rebuilds the image.
Deploy to Test: The Test Server deploys the verified integration to the Test environment using the committed deployment resources from Git.
Promote to Prod (Dev Server): Following verification on Test, that verified deployment definition is promoted on the Dev Server with its production-specific configuration—a configuration patch for Kubernetes or a Docker configuration for Docker—and committed to Git. Production never rebuilds the image.
Deploy to Prod: The Prod Server deploys the verified integration to the Production environment using the committed deployment resources from Git.

Ideal For

Teams that prefer a centralized, browser-based environment without managing local developer environments.
Organizations running on either Docker or Kubernetes that prefer built-in lifecycle management over configuring external CI/CD pipelines.

Advantages

Zero Local Setup: Developers only need a web browser to design, test, and release integrations.
Unified Interface: Design, build and promotion happen in one web interface; each environment's server deploys from Git.
Frictionless Onboarding: New team members can start contributing immediately without configuring local runtimes, IDE extensions, or credentials.

VS Code with Server Build

This approach bridges the gap between traditional local software development and server-managed operations. It empowers developers to use their preferred local IDE and Git workflows, while relying on the Talisman Dev Server to build container images and manage promotions across Test and Prod servers for both Kubernetes and Docker out of the box.

flowchart LR

    Studio["Studio"]

    subgraph servers [Talisman Servers]
        Dev["Dev"]
        Test["Test"]
        Prod["Prod"]
    end

%%    subgraph infra [Infra]
        Git[("Git")]
        Registry[("Image Registry")]
%%    end

    Studio -->|Code| Git
    Git -->|Code| Dev
    Dev -->|Resources| Git
    Dev -->|Images| Registry
    Git -.->|Resources| Test
    Git -.->|Resources| Prod
    Registry -.->|Images| Test
    Registry -.->|Images| Prod

Workflow

Design: Developers author integrations locally using Studio for VS Code, utilizing standard Git branching strategies (feature branches, pull requests) connected to their Git provider. Developers keep their local copy current with main, as the Dev Server also commits deployment resources to main.
Synchronize (Dev): Following a merge to main, the Dev Server synchronizes the project from Git to incorporate the merged changes before building.
Build (Dev): The Dev Server builds and publishes the immutable container image to the container registry. For Kubernetes, the build also generates the baseline deployment manifest in the project, which reaches Git when committed.
Deploy to Dev: The Dev Server deploys the integration to the development environment using the baseline deployment manifest and development configuration patch for Kubernetes, or the development Docker configuration for Docker.
Promote to Test (Dev Server): On the Dev Server, the deployment definition verified on Dev is promoted to Test by pairing it with Test's configuration (a configuration patch for Kubernetes or a Docker configuration for Docker) and committing the resources to main in Git. Test never rebuilds the image.
Deploy to Test: The Test Server deploys the verified integration to the Test environment using the committed resources from Git.
Promote to Prod (Dev Server): Following verification on Test, that verified deployment definition is promoted on the Dev Server with its production configuration (a configuration patch for Kubernetes or a Docker configuration for Docker) and committed to main in Git. Production never rebuilds the image.
Deploy to Prod: The Prod Server deploys the verified integration to the Production environment using the committed resources from Git.

Ideal For

Software engineering teams comfortable with IDEs, local development, and Git pull request workflows.
Teams that want code reviews and branching without the overhead of creating and maintaining dedicated CI/CD build pipelines for integration workloads.

Advantages

Developer Familiarity: Fully supports local development features, preferred linters, and native VS Code capabilities.
Standard Git Collaboration: Enables Git branching, peer code reviews, and commit hygiene before merging into main.
Managed Build Complexity: Offloads container packaging and environment promotion to the Talisman Dev Server while maintaining clean environment isolation across Test and Prod deployment targets.

VS Code with CI/CD

Designed for maximum flexibility and enterprise integration, this approach uncouples the build and deployment phases entirely from the Talisman Server, handing pipeline execution over to your organization's automation platforms.

flowchart LR

    Studio["Studio"]

    subgraph servers [Talisman Servers]
        direction LR
        Dev["Dev"]
        Test["Test"]
        Prod["Prod"]
    end

    subgraph infra [Infra]
        cicd["CI/CD"]
        Git[("Git")]
        Registry[("Image Registry")]
    end 

    Studio -->|Code| Git
    Git -->|Code| cicd
    cicd -->|Resources| Git
    cicd -->|Images| Registry
    cicd -->|Resources| Dev
    cicd -->|Resources| Test
    cicd -->|Resources| Prod
    Registry -.->|Images| Dev
    Registry -.->|Images| Test
    Registry -.->|Images| Prod

Workflow

Design: Integrations are developed locally using Studio for VS Code, utilizing branch-based Git workflows and pull requests into the main branch.
Build (via CI/CD): An automated pipeline triggers on repository updates to build and publish the container image. For Kubernetes, Talisman provides ready-to-use pipeline templates for GitHub Actions and Azure Pipelines that build and publish the image, generate the baseline deployment manifest, and commit it to the project repository. For Docker targets, or when using other CI/CD platforms (such as GitLab CI or Jenkins), the customer's pipeline carries out these same build and publishing steps.
Deploy to Dev (via CI/CD): The pipeline deploys the integration to the development environment. Talisman's pipeline templates apply the generated deployment manifest and development configuration patch to Kubernetes. For Docker targets, the customer's pipeline deploys the image to the Docker host using the development Docker configuration.
Promote to Test/Prod (via CI/CD): Environment promotion belongs entirely to the customer's pipeline and GitOps tooling (such as Argo CD or enterprise release orchestrators). The pipeline promotes the deployment definition verified on Dev across Test and Production alongside each environment's configuration (configuration patches for Kubernetes or environment Docker configurations for Docker) without rebuilding the container image.

Ideal For

Organizations with established Platform Engineering or DevOps practices and standardized release pipelines.
Teams with strict governance, compliance, automated testing, or separation-of-duty requirements.
Projects running on multi-cluster Kubernetes deployments or distributed Docker hosts managed through GitOps.

Advantages

Ecosystem Integration: Plugs natively into existing enterprise toolchains, automated testing suites, secret stores, and security scanners.
GitOps Alignment: Full support for modern GitOps methodologies where Git acts as the strict source of truth for application configuration and deployment history.
Granular Governance: Complete control over promotion stages, release approvals, security gates, and multi-environment deployment topologies.