Skip to main content

​
What It Does

Updating your application is as simple as asking Monk to deploy again, or pushing to your repository if you’ve set up CI/CD. Monk handles deployment, health checks, and automatically reverts if errors occur. Infrastructure changes, workload changes, and API configurations are applied automatically. Dependencies are upgraded seamlessly. No manual deployment process needed.

​
How It Works

​
Application Updates

Two ways to update your deployed application:

​
Method 1: Direct Deployment

Ask Monk to deploy your updated code: 
You: Deploy the latest changes
Monk analyzes changes, updates containers, applies configuration changes, and verifies everything works.

​
Method 2: Automatic via CI/CD

If you’ve set up CI/CD with Monk:
  1. Push changes to your repository
  2. CI pipeline automatically triggers
  3. Monk deploys updates to production
  4. Health checks verify deployment
  5. Done

​
What Gets Updated Automatically

When you deploy, Monk handles all necessary changes: Application updates:
  • Code changes in your services
  • New environment variables or configuration
  • Container image updates
  • Resource allocation changes (memory, CPU)
Infrastructure updates:
  • New services added to your application
  • Removed services cleaned up
  • Network routing updated
  • Firewall rules adjusted
API configuration updates:
  • Webhook URLs updated (Stripe, Auth0, etc.)
  • OAuth callback URLs adjusted
  • Third-party API resources reconfigured
  • See APIs for how this works
Dependency updates:
  • Supporting services upgraded (databases, caches, queues)
  • Package versions updated
  • See “Dependency Updates” section below
All applied seamlessly with zero downtime.

​
Health Checks & Validation

Monk ensures updates are fully applied and working before considering deployment complete: Readiness checks:
  • New containers must start successfully
  • Services must respond to health check endpoints
  • Database connections must establish
  • All dependencies must be reachable
Health validation:
  • Services monitored during rollout
  • Traffic gradually shifted to new version
  • Old version remains available during transition
  • If health checks fail, deployment stops
Automatic rollback on errors:
  • If new version fails health checks, Monk automatically reverts
  • If errors occur during deployment, changes are not applied
  • Old version remains running if new version doesn’t work
  • No manual intervention needed for rollback

​
Manual Rollback

Want to roll back to a previous version? Keep your application and Monk configuration in git: Rollback process:
  1. Switch to previous commit in git: git checkout <previous-commit>
  2. Ask Monk to deploy: deploy this version
  3. Monk deploys the previous version
  4. Application rolled back to previous state
Alternatively with CI/CD:
  1. Switch to previous commit
  2. Push to repository
  3. CI pipeline deploys previous version automatically
What gets rolled back:
  • Application code
  • Container configurations
  • Infrastructure configuration
  • Service wiring and connections
Monk treats git history as your deployment history - any commit can be deployed.

​
Dependency Updates

On every deployment, Monk checks for updates to supporting services: What Monk upgrades:
  • Databases - PostgreSQL, MySQL, MongoDB, Redis, etc.
  • Essential services - Message queues, caches, object storage
  • Third-party managed services - If newer versions available
How it works:
  • Monk checks package ecosystem for newer versions
  • Upgrades are applied seamlessly during deployment
  • No downtime for most upgrades
  • Data preserved during upgrades

​
Coming Soon

OS & Runtime Updates COMING SOON Monk will handle operating system and runtime updates autonomously: Planned capabilities:
  • Automatic OS updates on cloud VMs
  • Security patches applied in background
  • Runtime upgrades (container runtime)
  • Monk orchestrator self-updates
  • Zero-downtime infrastructure updates
How it will work:
  • VMs updated one at a time (rolling updates)
  • Services migrated to updated VMs automatically
  • No manual patching or maintenance windows required
  • Security patches applied within hours of release
This will ensure your infrastructure stays up-to-date and secure without any manual intervention.

​
What Makes This Different

Traditional update processes require:
  • Manually triggering deployments
  • Writing deployment scripts
  • Configuring health checks and readiness probes
  • Managing rollback procedures
  • Coordinating dependency upgrades
  • Scheduling maintenance windows for OS updates
  • Manually applying security patches
  • Testing rollback procedures separately
With Monk: Ask to deploy or push to git. Updates applied seamlessly with automatic health checks and rollbacks.

​
Key Capabilities

  • Simple deployment - Ask Monk or push to repository
  • Automatic change detection - Monk knows what changed and updates accordingly
  • Infrastructure updates - Services, networking, configurations updated automatically
  • API reconfiguration - Third-party service configurations updated
  • Dependency upgrades - Supporting services upgraded seamlessly
  • Health validation - Readiness and health checks ensure successful deployment
  • Automatic rollback - Failed deployments reverted automatically
  • Manual rollback via git - Deploy any previous commit
  • Zero-downtime deployments - Traffic shifted gradually to new version
  • CI/CD integration - Automatic updates on git push