Deploying AI Builder use cases requires a structured approach to move your solutions from development to production. This guide outlines strategies for versioning, deploying, and managing applications across different environments to ensure reliability and performance.

​
Deployment Strategies

Best for: Basic applications with minimal complexity, such as simple prompting agentsIn this approach, you use a single workspace for both development and production:
  • Development: Create and test your application directly in the workspace
  • Production: Once tested, the same workspace serves as the production environment
  • Version Control: Use versioning to save stable points for potential rollback
Advantages:
  • Simplest deployment approach
  • No need to migrate between workspaces
  • Quick iteration and updates
Considerations:
  • Limited separation between development and production
  • Higher risk of disruptive changes affecting live users
  • Best suited for applications with low complexity and minimal regulatory constraints

​
Versioning Your Application

1

Configure Git Repository

Set up version control for your workspace:
  1. Access workspace raw configuration by clicking “Edit source code” in the workspace action menu
  2. Add repository configuration to the end of the file:
repositories:
  github:
    name: My GitHub Repository
    type: git
    mode: read-write
    config:
      url: https://github.com/YourUser/your-repository.git
      branch: main
      auth:
        user: 'your git user'
        password: 'your git password'
You can use secrets for sensitive information:
auth:
  password: '{{secret.gitPassword}}'
For SSH authentication, use:
auth:
  sshkey: |-
    YOUR SSH
    KEY
    HERE
Remember to use git@github.com:YourUser/your-repository.git format for SSH URLs.
2

Push to Repository

Save your workspace state:
  1. From the workspace action menu, select “Versions”
  2. Choose the repository you configured
  3. Click “Push to repository”
  4. Enter a commit message describing your changes
  5. Submit to save the current state
This creates a snapshot of your workspace in the remote repository.
3

Pull from Repository

Retrieve saved workspace state:
  1. From the workspace action menu, select “Versions”
  2. Choose the repository you want to pull from
  3. Click “Pull from repository”
  4. Confirm the operation
This updates your workspace with the state stored in the repository.
4

Exclude Files from Import

Protect specific configurations during pulls:
repositories:
  github:
    name: My GitHub Repository
    type: git
    mode: read-write
    config:
      url: https://github.com/YourUser/your-repository.git
      branch: main
      auth:
        user: 'your git user'
        password: 'your git password'
    pull:
      exclude:
        - path: 'index' # Preserve workspace config
        - path: 'security' # Preserve security settings
        - path: 'pages/custom' # Preserve specific page
This prevents overwriting custom configurations when pulling changes.

​
Deployment Methods

​
Understanding What’s Versioned

Included in Versioning

Workspace components that are saved and deployed:

  • Pages and their configurations
  • Blocks and custom components
  • Automations and workflows
  • Security roles and permissions
  • App configurations
  • Workspace settings

Not Included in Versioning

Data that remains specific to each environment:

  • Events and their history
  • Collection data
  • Crawled documents
  • Uploaded files
  • User-specific settings
  • Runtime state
The versioned content is identical to what’s included in the workspace export archive.

​
Environment-Specific Configuration

Manage differences between environments:
1

Use Workspace Secrets

Store environment-specific values as secrets:
# In development workspace
secrets:
  apiEndpoint: https://dev-api.example.com
  maxRequests: 10

# In production workspace
secrets:
  apiEndpoint: https://api.example.com
  maxRequests: 100
Access these values in your application using:
{{secret.apiEndpoint}}
2

Conditional Logic

Implement environment-aware behavior in automations:
# Example automation with environment detection
slug: processData
do:
  - conditions: 
    "{{environment}} == 'production'":
      - callAPI:
          url: "{{secret.productionApi}}"
    default:
      - callAPI:
          url: "{{secret.developmentApi}}"
This allows your applications to adapt to different environments.

​
Handling Pull Results

After each import or repository pull, Prisme.ai emits a workspaces.imported event with details: 
{
 "files": [
  "index",
  "security",
  "pages/test.yml",
   ...
 ],
 "deleted": [
  "automations/removedAutomation.yml"
 ],
 "version": {
  "name": "latest",
  "repository": {
   "id": "yourRepositoryId"
  }
 },
 "errors": [
  {
   "msg": "Could not rename workspace slug from {oldSlug} to {newSlug} as it is already used by workspaceId zlkpbRF",
   "err": "SlugAlreadyInUse",
   "conflictingWorkspaceId": "..."
  }
 ]
}
You can create automations that listen for this event to:
  • Log deployment activities
  • Notify team members of successful deployments
  • Track errors and conflicts
  • Trigger post-deployment tasks

​
Deployment Best Practices

Version Everything

Maintain complete history of your application:

  • Commit changes frequently with clear messages
  • Use branches for feature development
  • Tag important releases (e.g., v1.0.0)
  • Document significant version changes
  • Never work directly in production

Test Before Deployment

Validate thoroughly before moving to production:

  • Test in development environment first
  • Verify integrations with external systems
  • Test with realistic data sets
  • Include user acceptance testing
  • Conduct security testing

Controlled Deployment

Implement safeguards around deployment:

  • Use approval workflows for production changes
  • Deploy during low-traffic periods
  • Implement monitoring during deployment
  • Prepare rollback procedures
  • Document deployment steps

Environment Isolation

Maintain clear boundaries between environments:

  • Use separate API keys for each environment
  • Configure different external service endpoints
  • Apply appropriate security controls by environment
  • Use visual indicators to distinguish environments
  • Limit production access to necessary personnel

​
Troubleshooting Deployments

​
Next Steps

RBAC

Configure role-based access control across environments

Integrations

Connect your applications to external systems

Testing & Debugging

Learn how to thoroughly test applications before deployment